voyageai-cli 1.30.0 → 1.30.1

package/src/commands/mcp-server.js

@@ -53,21 +53,35 @@ function registerMcpServer(program) {
   // Subcommand: install
   cmd
     .command('install [targets...]')
-    .description('Install vai MCP server into AI tool configs (claude, claude-code, cursor, windsurf, vscode, or "all")')
+    .description('Install vai MCP server into AI tool configs (claude, claude-code, cursor, windsurf, vscode, vscode-insiders, or "all")')
     .option('--force', 'Overwrite existing vai entry', false)
     .option('--transport <mode>', 'Transport mode: stdio or http', 'stdio')
     .option('--port <number>', 'HTTP port (http transport only)', (v) => parseInt(v, 10))
     .option('--api-key <key>', 'Voyage API key to embed in config')
+    .option('--mongodb-uri <uri>', 'MongoDB URI to embed in config')
+    .option('--db <name>', 'Default database name')
+    .option('--collection <name>', 'Default collection name')
+    .option('--workspace-path <path>', 'Workspace path for workspace-level config')
+    .option('--verbose', 'Enable verbose MCP logging')
+    .option('--show-tips', 'Show integration tips after install', true)
     .action((targets, opts) => {
       const { TARGETS, installTarget } = require('../mcp/install');
 
       if (!targets.length) {
         console.log('Usage: vai mcp install <target|all>');
-        console.log(`Available targets: ${Object.keys(TARGETS).join(', ')}, all`);
+        console.log(`\nAvailable targets:`);
+        for (const [key, target] of Object.entries(TARGETS)) {
+          const note = target.requiresWorkspace ? ' (workspace-level)' : '';
+          console.log(`  ${key.padEnd(18)} ${target.name}${note}`);
+        }
+        console.log(`  ${'all'.padEnd(18)} Install to all global targets`);
         return;
       }
 
-      const keys = targets.includes('all') ? Object.keys(TARGETS) : targets;
+      // Filter out workspace-only targets for 'all'
+      const keys = targets.includes('all')
+        ? Object.entries(TARGETS).filter(([_, t]) => !t.requiresWorkspace).map(([k]) => k)
+        : targets;
 
       for (const key of keys) {
         try {
@@ -76,8 +90,22 @@ function registerMcpServer(program) {
             transport: opts.transport,
             port: opts.port,
             apiKey: opts.apiKey,
+            mongodbUri: opts.mongodbUri,
+            db: opts.db,
+            collection: opts.collection,
+            workspacePath: opts.workspacePath,
+            verbose: opts.verbose,
           });
           console.log(result.installed ? `✅ ${result.message}` : `⚠️  ${result.message}`);
+
+          // Show tips if available and requested
+          if (result.tips && opts.showTips) {
+            console.log('');
+            for (const tip of result.tips) {
+              console.log(`   ${tip}`);
+            }
+            console.log('');
+          }
         } catch (err) {
           console.error(`❌ ${key}: ${err.message}`);
         }
@@ -123,6 +151,88 @@ function registerMcpServer(program) {
       }
       console.log('');
     });
+
+  // Subcommand: diagnose
+  cmd
+    .command('diagnose [target]')
+    .description('Diagnose MCP installation issues for a specific target')
+    .action((target) => {
+      const { diagnose, TARGETS } = require('../mcp/install');
+
+      if (!target) {
+        console.log('Usage: vai mcp diagnose <target>');
+        console.log(`Available targets: ${Object.keys(TARGETS).join(', ')}`);
+        return;
+      }
+
+      console.log(`\nvai MCP Diagnostics — ${target}\n`);
+
+      const results = diagnose(target);
+      for (const r of results) {
+        const icon = r.level === 'ok' ? '✅' : r.level === 'warning' ? '⚠️ ' : '❌';
+        console.log(`  ${icon} ${r.message}`);
+      }
+      console.log('');
+    });
+
+  // Subcommand: sample-config
+  cmd
+    .command('sample-config <target>')
+    .description('Generate sample MCP config for a target (cursor, vscode, etc.)')
+    .option('--transport <mode>', 'Transport mode: stdio or http', 'stdio')
+    .option('--port <number>', 'HTTP port', (v) => parseInt(v, 10))
+    .action((target, opts) => {
+      const { generateSampleConfig, TARGETS } = require('../mcp/install');
+
+      if (!TARGETS[target]) {
+        console.error(`Unknown target: ${target}. Available: ${Object.keys(TARGETS).join(', ')}`);
+        process.exit(1);
+      }
+
+      const sample = generateSampleConfig(target, {
+        transport: opts.transport,
+        port: opts.port,
+      });
+
+      if (!sample) {
+        console.error('Failed to generate sample config');
+        process.exit(1);
+      }
+
+      console.log(`\n# Sample MCP config for ${TARGETS[target].name}`);
+      console.log(`# Add this to your config file:\n`);
+      console.log(sample);
+    });
+
+  // Subcommand: info
+  cmd
+    .command('info <target>')
+    .description('Show detailed information about a target')
+    .action((target) => {
+      const { getTargetInfo } = require('../mcp/install');
+
+      const info = getTargetInfo(target);
+      if (!info) {
+        console.error(`Unknown target: ${target}`);
+        process.exit(1);
+      }
+
+      console.log(`\n${info.name}\n`);
+      console.log(`  Config path:    ${info.configPath || 'N/A (workspace-level only)'}`);
+      if (info.workspaceConfigPath) {
+        console.log(`  Workspace path: ${info.workspaceConfigPath}`);
+      }
+      if (info.requiresWorkspace) {
+        console.log(`  Note:           Requires --workspace-path option`);
+      }
+      if (info.tips.length > 0) {
+        console.log(`\n  Tips:`);
+        for (const tip of info.tips) {
+          console.log(`    ${tip}`);
+        }
+      }
+      console.log('');
+    });
 }
 
 module.exports = { registerMcpServer };

package/src/commands/playground.js

@@ -247,6 +247,24 @@ function createPlaygroundServer() {
         return;
       }
 
+      // Serve vendor assets (bundled JS libraries)
+      const vendorMatch = req.url.match(/^\/vendor\/([a-zA-Z0-9_.-]+\.js)$/);
+      if (req.method === 'GET' && vendorMatch) {
+        const vendorPath = path.join(__dirname, '..', 'playground', 'vendor', vendorMatch[1]);
+        if (fs.existsSync(vendorPath)) {
+          const data = fs.readFileSync(vendorPath);
+          res.writeHead(200, {
+            'Content-Type': 'application/javascript; charset=utf-8',
+            'Cache-Control': 'public, max-age=86400',
+          });
+          res.end(data);
+        } else {
+          res.writeHead(404);
+          res.end('Vendor asset not found');
+        }
+        return;
+      }
+
       // API: Models
       if (req.method === 'GET' && req.url === '/api/models') {
         const models = MODEL_CATALOG.filter(m => !m.legacy && !m.local && !m.unreleased);
@@ -460,6 +478,62 @@ function createPlaygroundServer() {
         return;
       }
 
+      // API: MCP status — installation status across all tools
+      if (req.method === 'GET' && req.url === '/api/mcp/status') {
+        try {
+          const { statusAll } = require('../mcp/install');
+          const results = statusAll();
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify(results));
+        } catch (err) {
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: err.message }));
+        }
+        return;
+      }
+
+      // API: MCP install — install vai into a target tool
+      if (req.method === 'POST' && req.url === '/api/mcp/install') {
+        try {
+          const body = await readBody(req);
+          const { target, force } = JSON.parse(body);
+          if (!target) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'target is required' }));
+            return;
+          }
+          const { installTarget } = require('../mcp/install');
+          const result = installTarget(target, { force: force || false });
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify(result));
+        } catch (err) {
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: err.message }));
+        }
+        return;
+      }
+
+      // API: MCP uninstall — remove vai from a target tool
+      if (req.method === 'POST' && req.url === '/api/mcp/uninstall') {
+        try {
+          const body = await readBody(req);
+          const { target } = JSON.parse(body);
+          if (!target) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'target is required' }));
+            return;
+          }
+          const { uninstallTarget } = require('../mcp/install');
+          const result = uninstallTarget(target);
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify(result));
+        } catch (err) {
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: err.message }));
+        }
+        return;
+      }
+
       // API: Settings origins — where each config value comes from
       if (req.method === 'GET' && req.url === '/api/settings/origins') {
         const { resolveLLMConfig } = require('../lib/llm');
@@ -1420,15 +1494,23 @@ function createPlaygroundServer() {
         // API: Validate a workflow definition
         if (req.url === '/api/workflows/validate') {
           const { validateWorkflow } = require('../lib/workflow');
-          const { definition } = parsed;
+          const { definition, mode } = parsed;
           if (!definition) {
             res.writeHead(400, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({ error: 'definition is required' }));
             return;
           }
-          const errors = validateWorkflow(definition);
+          const validationMode = mode || 'strict';
+          const result = validateWorkflow(definition, { mode: validationMode });
+          
           res.writeHead(200, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ valid: errors.length === 0, errors }));
+          
+          if (validationMode === 'draft') {
+            res.end(JSON.stringify(result));
+          } else {
+            // Backward compatible format for strict mode
+            res.end(JSON.stringify({ valid: result.length === 0, errors: result }));
+          }
           return;
         }
 
@@ -1532,6 +1614,32 @@ function createPlaygroundServer() {
         }
       }
 
+      // ── Export API endpoints ──
+      const exportMatch = req.url.match(/^\/api\/export\/(workflow|chat|search|benchmark)$/);
+      if (req.method === 'POST' && exportMatch) {
+        const context = exportMatch[1];
+        try {
+          const body = JSON.parse(await readBody(req));
+          const { exportArtifact } = require('../lib/export');
+          const result = await exportArtifact({
+            context,
+            format: body.format || 'json',
+            data: body.data || {},
+            options: body.options || {},
+          });
+          const isBinary = Buffer.isBuffer(result.content);
+          res.writeHead(200, {
+            'Content-Type': result.mimeType,
+            'Content-Disposition': `attachment; filename="${result.suggestedFilename}"`,
+          });
+          res.end(isBinary ? result.content : result.content);
+        } catch (err) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: err.message }));
+        }
+        return;
+      }
+
       // 404
       res.writeHead(404, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify({ error: 'Not found' }));

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