voyageai-cli 1.30.0 → 1.30.1

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

@@ -0,0 +1,189 @@
+'use strict';
+
+/**
+ * Render normalized data as Markdown.
+ * The shape of `normalized` varies by context — the context module sets a `_context` key.
+ * @param {object} normalized
+ * @param {object} options
+ * @returns {{ content: string, mimeType: string }}
+ */
+function renderMarkdown(normalized, options = {}) {
+  const ctx = normalized._context;
+  let md;
+  switch (ctx) {
+    case 'workflow':
+      md = renderWorkflowMd(normalized, options);
+      break;
+    case 'search':
+      md = renderSearchMd(normalized, options);
+      break;
+    case 'chat':
+      md = renderChatMd(normalized, options);
+      break;
+    case 'benchmark':
+      md = renderBenchmarkMd(normalized, options);
+      break;
+    default:
+      md = '# Export\n\n```json\n' + JSON.stringify(normalized, null, 2) + '\n```\n';
+  }
+  return { content: md, mimeType: 'text/markdown' };
+}
+
+// ── Workflow ──
+
+function renderWorkflowMd(n, opts) {
+  const lines = [];
+  lines.push(`# ${n.name || 'Workflow'}`);
+  lines.push('');
+  if (n.description) {
+    lines.push(n.description);
+    lines.push('');
+  }
+
+  // Metadata
+  if (n.version) lines.push(`**Version:** ${n.version}`);
+  const tools = (n.steps || []).map((s) => s.tool).filter(Boolean);
+  const unique = [...new Set(tools)];
+  if (unique.length) lines.push(`**Tools used:** ${unique.join(', ')}`);
+  const layers = n._executionLayers || null;
+  if (layers) lines.push(`**Execution layers:** ${layers} (sequential)`);
+  lines.push('');
+
+  // Inputs table
+  if (n.inputs && Object.keys(n.inputs).length > 0) {
+    lines.push('## Inputs');
+    lines.push('');
+    lines.push('| Parameter | Type | Required | Default | Description |');
+    lines.push('|-----------|------|----------|---------|-------------|');
+    for (const [key, schema] of Object.entries(n.inputs)) {
+      const type = schema.type || 'string';
+      const req = schema.required ? 'Yes' : 'No';
+      const def = schema.default !== undefined ? String(schema.default) : '—';
+      const desc = schema.description || '';
+      lines.push(`| ${key} | ${type} | ${req} | ${def} | ${desc} |`);
+    }
+    lines.push('');
+  }
+
+  // Steps
+  if (n.steps && n.steps.length > 0) {
+    lines.push('## Steps');
+    lines.push('');
+    const deps = n._dependencyMap || {};
+    n.steps.forEach((step, i) => {
+      const label = step.name || step.description || step.id;
+      lines.push(`### ${i + 1}. ${label}`);
+      if (step.tool) lines.push(`- **Tool:** ${step.tool}`);
+      const stepDeps = deps[step.id];
+      if (stepDeps && stepDeps.length > 0) {
+        lines.push(`- **Depends on:** ${stepDeps.join(', ')}`);
+      } else {
+        lines.push('- **Depends on:** (none — first step)');
+      }
+      if (step.description && step.description !== label) {
+        lines.push(`- **Configuration:** ${step.description}`);
+      }
+      lines.push('');
+    });
+  }
+
+  // Output
+  if (n.output) {
+    lines.push('## Output');
+    lines.push('');
+    lines.push(`Returns: \`${n.output}\``);
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+// ── Search Results ──
+
+function renderSearchMd(n, opts) {
+  const lines = [];
+  lines.push('# Search Results');
+  lines.push('');
+  if (n.query) lines.push(`**Query:** ${n.query}`);
+  if (n.collection) lines.push(`**Collection:** ${n.collection}`);
+  if (n.model) lines.push(`**Model:** ${n.model}`);
+  const total = (n.results || []).length;
+  lines.push(`**Results:** ${total}`);
+  lines.push('');
+
+  (n.results || []).forEach((r, i) => {
+    lines.push(`### ${i + 1}. ${r.source || 'Result'} (score: ${r.score ?? '—'})`);
+    if (r.rerankedScore !== undefined) lines.push(`- **Reranked score:** ${r.rerankedScore}`);
+    const text = opts.includeFullText ? r.text : (r.text || '').slice(0, 200);
+    if (text) {
+      lines.push('');
+      lines.push(`> ${text}`);
+    }
+    lines.push('');
+  });
+
+  return lines.join('\n');
+}
+
+// ── Chat Session ──
+
+function renderChatMd(n, opts) {
+  const lines = [];
+  const sessionId = n.sessionId || n.id || 'unknown';
+  lines.push(`# Chat Session: ${sessionId}`);
+  lines.push('');
+  if (n.startedAt) lines.push(`**Date:** ${n.startedAt}`);
+  if (n.provider && n.model) lines.push(`**Provider:** ${n.provider} (${n.model})`);
+  else if (n.model) lines.push(`**Model:** ${n.model}`);
+  if (n.collection) lines.push(`**Knowledge Base:** ${n.collection}`);
+  const turns = (n.turns || []).length;
+  lines.push(`**Turns:** ${turns}`);
+  lines.push('');
+  lines.push('---');
+  lines.push('');
+
+  (n.turns || []).forEach((turn) => {
+    const role = turn.role === 'user' ? 'User' : 'vai';
+    lines.push(`**${role}:**`);
+    lines.push(turn.content || '');
+    if (opts.includeSources !== false && turn.context && turn.context.length > 0) {
+      lines.push('');
+      lines.push('> **Sources:**');
+      turn.context.forEach((src, i) => {
+        const rel = src.score !== undefined ? ` (relevance: ${src.score})` : '';
+        lines.push(`> ${i + 1}. ${src.source || 'unknown'}${rel}`);
+      });
+    }
+    lines.push('');
+    lines.push('---');
+    lines.push('');
+  });
+
+  return lines.join('\n');
+}
+
+// ── Benchmark ──
+
+function renderBenchmarkMd(n, opts) {
+  const lines = [];
+  lines.push('# Benchmark Results');
+  lines.push('');
+  if (n.name) lines.push(`**Benchmark:** ${n.name}`);
+  if (n.date) lines.push(`**Date:** ${n.date}`);
+  lines.push('');
+
+  const results = n.results || n.rows || [];
+  if (results.length > 0) {
+    const cols = Object.keys(results[0]);
+    lines.push('| ' + cols.join(' | ') + ' |');
+    lines.push('| ' + cols.map(() => '---').join(' | ') + ' |');
+    results.forEach((row) => {
+      lines.push('| ' + cols.map((c) => String(row[c] ?? '')).join(' | ') + ' |');
+    });
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+module.exports = { renderMarkdown };

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

@@ -0,0 +1,274 @@
+'use strict';
+
+const {
+  VAI_TOOLS,
+  CONTROL_FLOW_TOOLS,
+  PROCESSING_TOOLS,
+  INTEGRATION_TOOLS,
+  buildDependencyGraph,
+} = require('../../workflow');
+
+// ════════════════════════════════════════════════════════════════════
+// Tool → Category mapping
+// ════════════════════════════════════════════════════════════════════
+
+function getToolCategory(tool) {
+  if (!tool) return 'utility';
+  if (tool === 'rerank') return 'retrieval';
+  if (['query', 'search'].includes(tool)) return 'retrieval';
+  if (['embed', 'similarity'].includes(tool)) return 'embedding';
+  if (tool === 'generate') return 'generation';
+  if (tool === 'ingest') return 'ingestion';
+  if (CONTROL_FLOW_TOOLS.has(tool)) return 'control';
+  if (PROCESSING_TOOLS.has(tool)) return 'utility';
+  if (INTEGRATION_TOOLS.has(tool)) return 'utility';
+  return 'utility';
+}
+
+// ════════════════════════════════════════════════════════════════════
+// Emoji per category
+// ════════════════════════════════════════════════════════════════════
+
+const CATEGORY_EMOJI = {
+  retrieval: '🔍',
+  embedding: '🧬',
+  generation: '✨',
+  control: '⚙️',
+  utility: '🔧',
+  ingestion: '📥',
+};
+
+// ════════════════════════════════════════════════════════════════════
+// Mermaid node shape per category (spec Section 7.1)
+// ════════════════════════════════════════════════════════════════════
+
+function wrapNodeShape(id, label, category, isConditional) {
+  if (isConditional) return `${id}{"${label}"}`;
+  switch (category) {
+    case 'retrieval':  return `${id}(["${label}"])`;   // stadium
+    case 'embedding':  return `${id}("${label}")`;     // rounded
+    case 'generation': return `${id}[/"${label}"/]`;   // trapezoid
+    case 'control':    return `${id}{"${label}"}`;     // diamond
+    case 'ingestion':  return `${id}[["${label}"]]`;   // subroutine
+    case 'utility':
+    default:           return `${id}("${label}")`;     // rounded
+  }
+}
+
+// ════════════════════════════════════════════════════════════════════
+// Style class definitions (spec Section 7.2)
+// ════════════════════════════════════════════════════════════════════
+
+const CLASS_DEFS = {
+  retrieval:  'classDef retrieval fill:#00838F,stroke:#00D4AA,color:#fff',
+  embedding:  'classDef embedding fill:#4A148C,stroke:#CE93D8,color:#fff',
+  generation: 'classDef generation fill:#6A1B9A,stroke:#CE93D8,color:#fff',
+  control:    'classDef control fill:#424242,stroke:#9E9E9E,color:#fff',
+  utility:    'classDef utility fill:#E65100,stroke:#FFB74D,color:#fff',
+  ingestion:  'classDef ingestion fill:#1B5E20,stroke:#66BB6A,color:#fff',
+};
+
+// ════════════════════════════════════════════════════════════════════
+// Main conversion
+// ════════════════════════════════════════════════════════════════════
+
+/**
+ * Convert a workflow definition to Mermaid flowchart syntax.
+ *
+ * @param {object} workflow - Parsed workflow JSON
+ * @param {object} [options]
+ * @param {string} [options.theme='dark']
+ * @param {string} [options.direction='TD']
+ * @param {boolean} [options.includeStepIds=false]
+ * @param {boolean} [options.includeToolEmoji=true]
+ * @param {boolean} [options.colorCoded=true]
+ * @param {boolean} [options.includeParallelism=false]
+ * @returns {string} Mermaid diagram source
+ */
+function workflowToMermaid(workflow, options = {}) {
+  const {
+    theme = 'dark',
+    direction = 'TD',
+    includeStepIds = false,
+    includeToolEmoji = true,
+    colorCoded = true,
+    includeParallelism = false,
+  } = options;
+
+  const steps = workflow.steps || [];
+  if (steps.length === 0) return '';
+
+  const lines = [];
+
+  // Init directive
+  lines.push(`%%{init: {'theme': '${theme}', 'themeVariables': { 'primaryColor': '#00D4AA' }}}%%`);
+  lines.push(`graph ${direction}`);
+
+  // Class definitions
+  if (colorCoded) {
+    const usedCategories = new Set(steps.map((s) => getToolCategory(s.tool)));
+    for (const cat of usedCategories) {
+      if (CLASS_DEFS[cat]) lines.push(`    ${CLASS_DEFS[cat]}`);
+    }
+    lines.push('');
+  }
+
+  // Build dependency info — buildDependencyGraph returns Map<string, Set<string>>
+  const depGraphMap = buildDependencyGraph(steps);
+  // Convert to plain object with arrays for easier iteration
+  const depGraph = {};
+  for (const [id, deps] of depGraphMap) {
+    depGraph[id] = [...deps];
+  }
+
+  // Build execution layers if needed (for subgraph grouping)
+  let layers = null;
+  if (includeParallelism) {
+    layers = buildLayers(steps, depGraph);
+  }
+
+  // Node definitions
+  if (layers && includeParallelism) {
+    layers.forEach((layerStepIds, i) => {
+      if (layerStepIds.length > 1) {
+        lines.push(`    subgraph "Layer ${i + 1} (parallel)"`);
+        for (const sid of layerStepIds) {
+          const step = steps.find((s) => s.id === sid);
+          lines.push(`        ${buildNode(step, { includeStepIds, includeToolEmoji })}`);
+        }
+        lines.push('    end');
+      } else if (layerStepIds.length === 1) {
+        const step = steps.find((s) => s.id === layerStepIds[0]);
+        lines.push(`    ${buildNode(step, { includeStepIds, includeToolEmoji })}`);
+      }
+    });
+  } else {
+    for (const step of steps) {
+      lines.push(`    ${buildNode(step, { includeStepIds, includeToolEmoji })}`);
+    }
+  }
+
+  lines.push('');
+
+  // Edges
+  const stepIds = new Set(steps.map((s) => s.id));
+  for (const step of steps) {
+    const deps = depGraph[step.id] || [];
+
+    // Also detect implicit deps from condition/forEach that reference step IDs
+    const implicitDeps = new Set();
+    if (step.condition) {
+      for (const sid of stepIds) {
+        if (step.condition.includes(sid) && sid !== step.id && !deps.includes(sid)) {
+          implicitDeps.add(sid);
+        }
+      }
+    }
+    if (step.forEach) {
+      for (const sid of stepIds) {
+        if (step.forEach.includes(sid) && sid !== step.id && !deps.includes(sid)) {
+          implicitDeps.add(sid);
+        }
+      }
+    }
+
+    for (const dep of deps) {
+      const hasCondition = step.condition && step.condition.includes(dep);
+      const arrow = hasCondition ? '-.->' : '-->';
+      lines.push(`    ${dep} ${arrow} ${step.id}`);
+    }
+    for (const dep of implicitDeps) {
+      lines.push(`    ${dep} -.-> ${step.id}`);
+    }
+  }
+
+  // Apply class assignments
+  if (colorCoded) {
+    lines.push('');
+    for (const step of steps) {
+      const cat = getToolCategory(step.tool);
+      lines.push(`    class ${step.id} ${cat}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Build a single node definition string.
+ */
+function buildNode(step, opts) {
+  const category = getToolCategory(step.tool);
+  const isConditional = !!step.condition;
+  const isForEach = !!step.forEach;
+
+  let label = step.name || step.description || step.id;
+  if (opts.includeToolEmoji && CATEGORY_EMOJI[category]) {
+    label = `${CATEGORY_EMOJI[category]} ${label}`;
+  }
+  if (opts.includeStepIds) {
+    label = `${label} (${step.id})`;
+  }
+  if (isConditional) {
+    const condText = step.condition.length > 30
+      ? step.condition.slice(0, 27) + '...'
+      : step.condition;
+    label = `${label}<br/><small>condition: ${condText}</small>`;
+  }
+  if (isForEach) {
+    label = `${label}<br/><small>∀ item in ${step.forEach}</small>`;
+  }
+
+  return wrapNodeShape(step.id, label, category, isConditional);
+}
+
+/**
+ * Build execution layers via topological sort / breadth-first layering.
+ */
+function buildLayers(steps, depGraph) {
+  const inDegree = {};
+  const stepIds = steps.map((s) => s.id);
+  for (const id of stepIds) inDegree[id] = 0;
+  for (const [id, deps] of Object.entries(depGraph)) {
+    inDegree[id] = (deps || []).length;
+  }
+
+  const layers = [];
+  const remaining = new Set(stepIds);
+
+  while (remaining.size > 0) {
+    const layer = [];
+    for (const id of remaining) {
+      if ((inDegree[id] || 0) === 0) layer.push(id);
+    }
+    if (layer.length === 0) break; // cycle guard
+    layers.push(layer);
+    for (const id of layer) {
+      remaining.delete(id);
+      // Decrement in-degree of dependents
+      for (const [depId, deps] of Object.entries(depGraph)) {
+        if (remaining.has(depId) && deps.includes(id)) {
+          inDegree[depId]--;
+        }
+      }
+    }
+  }
+
+  return layers;
+}
+
+/**
+ * Render as Mermaid format for the export system.
+ * @param {object} normalized - workflow normalized data
+ * @param {object} options
+ * @returns {{ content: string, mimeType: string }}
+ */
+function renderMermaid(normalized, options = {}) {
+  const mermaid = workflowToMermaid(normalized, options);
+  return {
+    content: mermaid,
+    mimeType: 'text/x-mermaid',
+  };
+}
+
+module.exports = { workflowToMermaid, renderMermaid, getToolCategory, buildLayers };

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

@@ -0,0 +1,117 @@
+'use strict';
+
+/**
+ * Render a chat session (or any markdown content) as PDF using Playwright.
+ *
+ * @param {object} normalized
+ * @param {object} options
+ * @param {string} [options.theme='dark'] - 'dark' | 'light'
+ * @returns {Promise<{ content: Buffer, mimeType: string }>}
+ */
+async function renderPdf(normalized, options = {}) {
+  if (normalized._context !== 'chat') {
+    throw new Error(`PDF export currently supported for chat sessions only (got: ${normalized._context})`);
+  }
+
+  const html = buildChatHtml(normalized, options);
+  const pdf = await htmlToPdf(html, options);
+  return { content: pdf, mimeType: 'application/pdf' };
+}
+
+/**
+ * Build styled HTML from a chat session for PDF rendering.
+ */
+function buildChatHtml(chat, options = {}) {
+  const theme = options.theme || 'dark';
+  const isDark = theme === 'dark';
+  const bg = isDark ? '#1e1e1e' : '#ffffff';
+  const fg = isDark ? '#e0e0e0' : '#1a1a1a';
+  const userBg = isDark ? '#2a2a2a' : '#f5f5f5';
+  const asstBg = isDark ? '#1a2a3a' : '#e8f4f8';
+  const accent = '#00D4AA';
+
+  const turns = (chat.turns || []).map((t) => {
+    const isUser = t.role === 'user';
+    const roleName = isUser ? 'User' : 'vai';
+    const msgBg = isUser ? userBg : asstBg;
+    const content = escapeHtml(t.content || '').replace(/\n/g, '<br/>');
+
+    let sources = '';
+    if (t.context && t.context.length > 0 && options.includeSources !== false) {
+      const srcItems = t.context.map((s, i) => {
+        const rel = s.score !== undefined ? ` (relevance: ${s.score})` : '';
+        return `<li style="font-size:12px;color:#888;">${escapeHtml(s.source || 'unknown')}${rel}</li>`;
+      }).join('');
+      sources = `<ul style="margin:4px 0 0 16px;padding:0;">${srcItems}</ul>`;
+    }
+
+    let meta = '';
+    if (options.includeMetadata && t.metadata) {
+      const parts = [];
+      if (t.metadata.tokensUsed) parts.push(`${t.metadata.tokensUsed} tokens`);
+      if (t.metadata.retrievalTimeMs) parts.push(`retrieval: ${t.metadata.retrievalTimeMs}ms`);
+      if (t.metadata.generationTimeMs) parts.push(`generation: ${t.metadata.generationTimeMs}ms`);
+      if (parts.length) {
+        meta = `<div style="font-size:11px;color:#666;margin-top:4px;">${parts.join(' · ')}</div>`;
+      }
+    }
+
+    return `<div style="background:${msgBg};padding:12px 16px;border-radius:8px;margin:8px 0;">
+      <div style="font-weight:bold;color:${accent};margin-bottom:6px;">${roleName}</div>
+      <div>${content}</div>
+      ${sources}${meta}
+    </div>`;
+  }).join('');
+
+  const sessionId = chat.sessionId || chat.id || '';
+  const headerParts = [];
+  if (chat.startedAt) headerParts.push(`Date: ${chat.startedAt}`);
+  if (chat.provider && chat.model) headerParts.push(`Provider: ${chat.provider} (${chat.model})`);
+  else if (chat.model) headerParts.push(`Model: ${chat.model}`);
+  if (chat.collection) headerParts.push(`Knowledge Base: ${chat.collection}`);
+  headerParts.push(`Turns: ${(chat.turns || []).length}`);
+
+  return `<!DOCTYPE html>
+<html><head><meta charset="utf-8">
+<style>
+  body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; background: ${bg}; color: ${fg}; margin: 40px; line-height: 1.6; }
+  h1 { color: ${accent}; font-size: 24px; margin-bottom: 4px; }
+  .meta { font-size: 13px; color: #888; margin-bottom: 24px; }
+  .footer { font-size: 11px; color: #666; text-align: center; margin-top: 40px; border-top: 1px solid #333; padding-top: 12px; }
+</style>
+</head><body>
+<h1>Chat Session: ${escapeHtml(sessionId)}</h1>
+<div class="meta">${headerParts.join(' · ')}</div>
+<hr style="border:none;border-top:1px solid #333;margin:16px 0;">
+${turns}
+<div class="footer">Generated by vai · voyageai-cli</div>
+</body></html>`;
+}
+
+/**
+ * Convert HTML to PDF using Playwright.
+ */
+async function htmlToPdf(html, options = {}) {
+  const { chromium } = require('playwright');
+  const browser = await chromium.launch({ headless: true });
+  try {
+    const page = await browser.newPage();
+    await page.setContent(html, { waitUntil: 'networkidle' });
+
+    const pdf = await page.pdf({
+      format: 'A4',
+      margin: { top: '20mm', bottom: '20mm', left: '15mm', right: '15mm' },
+      printBackground: true,
+    });
+
+    return pdf;
+  } finally {
+    await browser.close();
+  }
+}
+
+function escapeHtml(str) {
+  return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+
+module.exports = { renderPdf, buildChatHtml, htmlToPdf };

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

@@ -0,0 +1,96 @@
+'use strict';
+
+/**
+ * Render PNG from Mermaid diagram via Playwright.
+ *
+ * @param {object} normalized
+ * @param {object} options
+ * @param {string} [options.resolution='2x'] - '1x' | '2x' | '3x'
+ * @param {string} [options.background='transparent'] - 'transparent' | 'dark' | 'light'
+ * @param {boolean} [options.includeWatermark=true]
+ * @param {boolean} [options.fitToContent=true]
+ * @returns {Promise<{ content: Buffer, mimeType: string }>}
+ */
+async function renderPng(normalized, options = {}) {
+  // If raw PNG buffer provided (from Electron canvas capture)
+  if (normalized._pngBuffer) {
+    return { content: normalized._pngBuffer, mimeType: 'image/png' };
+  }
+
+  const { workflowToMermaid } = require('./mermaid-export');
+
+  if (normalized._context !== 'workflow' && normalized._context !== 'benchmark') {
+    throw new Error(`PNG export not supported for context: ${normalized._context}`);
+  }
+
+  const mermaidSrc = normalized._context === 'workflow'
+    ? workflowToMermaid(normalized, options)
+    : null;
+
+  if (!mermaidSrc) {
+    throw new Error('No Mermaid source available for PNG rendering');
+  }
+
+  const png = await renderMermaidToPng(mermaidSrc, options);
+  return { content: png, mimeType: 'image/png' };
+}
+
+/**
+ * Render Mermaid syntax to PNG using Playwright.
+ */
+async function renderMermaidToPng(mermaidSrc, options = {}) {
+  const { chromium } = require('playwright');
+  const resolution = options.resolution || '2x';
+  const scale = parseInt(resolution) || 2;
+  const background = options.background || 'transparent';
+  const bgColor = background === 'dark' ? '#1e1e1e' : background === 'light' ? '#ffffff' : 'transparent';
+
+  const browser = await chromium.launch({ headless: true });
+  try {
+    const page = await browser.newPage({
+      deviceScaleFactor: scale,
+    });
+
+    const html = `<!DOCTYPE html>
+<html><head>
+<script src="https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js"></script>
+</head><body style="margin:0;padding:16px;background:${bgColor};">
+<pre class="mermaid">${escapeHtml(mermaidSrc)}</pre>
+<script>mermaid.initialize({ startOnLoad: true, theme: '${options.theme || 'dark'}' });</script>
+</body></html>`;
+
+    await page.setContent(html, { waitUntil: 'networkidle' });
+    await page.waitForSelector('svg', { timeout: 10000 });
+
+    const fitToContent = options.fitToContent !== false;
+
+    let screenshotOpts = { type: 'png' };
+    if (background === 'transparent') {
+      screenshotOpts.omitBackground = true;
+    }
+
+    if (fitToContent) {
+      const svgEl = await page.$('svg');
+      const box = await svgEl.boundingBox();
+      if (box) {
+        screenshotOpts.clip = {
+          x: Math.max(0, box.x - 8),
+          y: Math.max(0, box.y - 8),
+          width: box.width + 16,
+          height: box.height + 16,
+        };
+      }
+    }
+
+    const buffer = await page.screenshot(screenshotOpts);
+    return buffer;
+  } finally {
+    await browser.close();
+  }
+}
+
+function escapeHtml(str) {
+  return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+
+module.exports = { renderPng, renderMermaidToPng };