voyageai-cli 1.29.0 → 1.30.1

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 };

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

@@ -0,0 +1,50 @@
+'use strict';
+
+const path = require('path');
+const pkg = require(path.resolve(__dirname, '..', '..', '..', '..', 'package.json'));
+
+/**
+ * Render normalized data as JSON.
+ * @param {object} normalized
+ * @param {object} options
+ * @returns {{ content: string, mimeType: string }}
+ */
+function renderJson(normalized, options = {}) {
+  const output = { ...normalized };
+  if (options.includeMetadata !== false) {
+    output._exportMeta = {
+      exportedAt: new Date().toISOString(),
+      vaiVersion: pkg.version,
+      ...(normalized._exportMeta || {}),
+    };
+  }
+  // Remove internal _exportMeta from source if we rebuilt it
+  if (normalized._exportMeta && output._exportMeta !== normalized._exportMeta) {
+    delete output._exportMeta;
+  }
+  return {
+    content: JSON.stringify(output, null, 2),
+    mimeType: 'application/json',
+  };
+}
+
+/**
+ * Render normalized data as JSONL (one record per line).
+ * Expects normalized.results or normalized.items to be an array.
+ * @param {object} normalized
+ * @param {object} options
+ * @returns {{ content: string, mimeType: string }}
+ */
+function renderJsonl(normalized, options = {}) {
+  const records = normalized.results || normalized.items || [];
+  if (!Array.isArray(records)) {
+    throw new Error('JSONL export requires an array of records (results or items)');
+  }
+  const lines = records.map((r) => JSON.stringify(r));
+  return {
+    content: lines.join('\n'),
+    mimeType: 'application/x-ndjson',
+  };
+}
+
+module.exports = { renderJson, renderJsonl };

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 };