voyageai-cli 1.30.0 → 1.30.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "voyageai-cli",
-  "version": "1.30.0",
+  "version": "1.30.1",
   "description": "CLI for Voyage AI embeddings, reranking, and MongoDB Atlas Vector Search",
   "bin": {
     "vai": "./src/cli.js"

package/src/cli.js

@@ -38,6 +38,9 @@ const { registerBug } = require('./commands/bug');
 const { registerChat } = require('./commands/chat');
 const { registerMcpServer } = require('./commands/mcp-server');
 const { registerWorkflow } = require('./commands/workflow');
+const { registerIndexWorkspace } = require('./commands/index-workspace');
+const { registerExport } = require('./commands/export');
+const { registerImport } = require('./commands/import');
 const { showBanner, showQuickStart, getVersion } = require('./lib/banner');
 
 const version = getVersion();
@@ -80,6 +83,9 @@ registerBug(program);
 registerChat(program);
 registerMcpServer(program);
 registerWorkflow(program);
+registerIndexWorkspace(program);
+registerExport(program);
+registerImport(program);
 
 // Append disclaimer to all help output
 program.addHelpText('after', `

package/src/commands/chat.js

@@ -499,7 +499,7 @@ async function handleSlashCommand(input, ctx) {
       console.log('  /context    Show retrieved context from last query');
       console.log('  /clear      Clear conversation history');
       console.log('  /model      Show or switch LLM model (/model <name>)');
-      console.log('  /export     Export conversation (markdown or json)');
+      console.log('  /export [format] [file]  Export conversation (markdown, json, pdf)');
       if (isAgent) {
         console.log('  /tools      Show tool calls from last response');
         console.log('  /export-workflow  Export last tool sequence as workflow');
@@ -613,17 +613,38 @@ async function handleSlashCommand(input, ctx) {
     }
 
     case '/export': {
-      const format = parts[1] || 'md';
-      if (format === 'json') {
-        const data = history.exportJSON();
-        const filename = `chat-${history.sessionId.slice(0, 8)}.json`;
-        fs.writeFileSync(filename, JSON.stringify(data, null, 2) + '\n');
-        console.log(ui.success(`Exported to ${filename}`));
-      } else {
-        const md = history.exportMarkdown();
-        const filename = `chat-${history.sessionId.slice(0, 8)}.md`;
-        fs.writeFileSync(filename, md);
+      const format = parts[1] || 'markdown';
+      const outFile = parts[2] || null;
+      const validFormats = ['json', 'markdown', 'md', 'pdf'];
+
+      if (!validFormats.includes(format)) {
+        console.log(pc.dim(`  Unknown format: ${format}. Use: ${validFormats.join(', ')}`));
+        return true;
+      }
+
+      try {
+        const { exportArtifact } = require('../lib/export');
+        const chatData = history.exportJSON();
+        const effectiveFormat = format === 'md' ? 'markdown' : format;
+
+        const result = await exportArtifact({
+          context: 'chat',
+          format: effectiveFormat,
+          data: chatData,
+          options: {},
+        });
+
+        const isBinary = Buffer.isBuffer(result.content);
+        const filename = outFile || result.suggestedFilename;
+
+        if (isBinary) {
+          fs.writeFileSync(filename, result.content);
+        } else {
+          fs.writeFileSync(filename, result.content, 'utf-8');
+        }
         console.log(ui.success(`Exported to ${filename}`));
+      } catch (err) {
+        console.log(pc.red(`  Export failed: ${err.message}`));
       }
       return true;
     }

package/src/commands/export.js

@@ -0,0 +1,124 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { exportArtifact, getFormatsForContext } = require('../lib/export');
+const { copyToClipboard } = require('../lib/export/formats/clipboard-export');
+const ui = require('../lib/ui');
+
+/**
+ * Register the export command on a Commander program.
+ * @param {import('commander').Command} program
+ */
+function registerExport(program) {
+  const exportCmd = program
+    .command('export')
+    .description('Export workflows, chat sessions, and search results in various formats');
+
+  // ── export workflow <file> ──
+  exportCmd
+    .command('workflow <file>')
+    .description('Export a workflow definition')
+    .option('-f, --format <fmt>', 'Output format (json, markdown, mermaid, svg, png, clipboard)', 'json')
+    .option('-o, --output <path>', 'Output file path (stdout if omitted)')
+    .option('--options <json>', 'Format-specific options as JSON string', '{}')
+    .option('--clipboard', 'Copy to system clipboard')
+    .action(async (file, opts) => {
+      await handleExport('workflow', file, opts);
+    });
+
+  // ── export chat <sessionId> ──
+  exportCmd
+    .command('chat <sessionId>')
+    .description('Export a chat session')
+    .option('-f, --format <fmt>', 'Output format (json, markdown, pdf, clipboard)', 'json')
+    .option('-o, --output <path>', 'Output file path (stdout if omitted)')
+    .option('--options <json>', 'Format-specific options as JSON string', '{}')
+    .option('--clipboard', 'Copy to system clipboard')
+    .action(async (sessionId, opts) => {
+      await handleExport('chat', sessionId, opts);
+    });
+
+  // ── export results <file> ──
+  exportCmd
+    .command('results <file>')
+    .description('Export saved search results')
+    .option('-f, --format <fmt>', 'Output format (json, jsonl, csv, markdown, clipboard)', 'json')
+    .option('-o, --output <path>', 'Output file path (stdout if omitted)')
+    .option('--options <json>', 'Format-specific options as JSON string', '{}')
+    .option('--clipboard', 'Copy to system clipboard')
+    .action(async (file, opts) => {
+      await handleExport('search', file, opts);
+    });
+}
+
+/**
+ * Handle an export action.
+ */
+async function handleExport(context, source, opts) {
+  try {
+    // Load source data
+    let data;
+    if (context === 'chat') {
+      // Chat sessions are loaded from MongoDB — for now, support JSON file input too
+      data = loadJsonFile(source);
+    } else {
+      data = loadJsonFile(source);
+    }
+
+    const format = opts.clipboard ? 'clipboard' : opts.format;
+    const formatOptions = parseOptions(opts.options);
+
+    const result = await exportArtifact({
+      context,
+      format,
+      data,
+      options: formatOptions,
+    });
+
+    const isBinary = Buffer.isBuffer(result.content);
+
+    // Output
+    if (opts.clipboard) {
+      console.log(ui.success ? ui.success('Copied to clipboard') : '✓ Copied to clipboard');
+    } else if (opts.output) {
+      const outPath = path.resolve(opts.output);
+      if (isBinary) {
+        fs.writeFileSync(outPath, result.content);
+      } else {
+        fs.writeFileSync(outPath, result.content, 'utf-8');
+      }
+      console.log(ui.success ? ui.success(`Saved to ${outPath}`) : `✓ Saved to ${outPath}`);
+    } else if (isBinary) {
+      // Binary to stdout requires --output
+      console.error(ui.error ? ui.error('Binary formats (png, pdf) require --output <path>') : '✗ Binary formats (png, pdf) require --output <path>');
+      process.exitCode = 1;
+    } else {
+      // stdout
+      process.stdout.write(result.content);
+      if (!result.content.endsWith('\n')) process.stdout.write('\n');
+    }
+  } catch (err) {
+    console.error(ui.error ? ui.error(err.message) : `✗ ${err.message}`);
+    process.exitCode = 1;
+  }
+}
+
+function loadJsonFile(filePath) {
+  const resolved = path.resolve(filePath);
+  if (!fs.existsSync(resolved)) {
+    throw new Error(`File not found: ${resolved}`);
+  }
+  const raw = fs.readFileSync(resolved, 'utf-8');
+  return JSON.parse(raw);
+}
+
+function parseOptions(jsonStr) {
+  try {
+    return JSON.parse(jsonStr || '{}');
+  } catch {
+    throw new Error(`Invalid --options JSON: ${jsonStr}`);
+  }
+}
+
+module.exports = { registerExport };

package/src/commands/import.js

@@ -0,0 +1,195 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const ui = require('../lib/ui');
+const { validateWorkflow } = require('../lib/workflow');
+
+/**
+ * Register the import command on a Commander program.
+ * @param {import('commander').Command} program
+ */
+function registerImport(program) {
+  program
+    .command('import <file>')
+    .description('Import a workflow definition or chat session exported by vai')
+    .option('--type <type>', 'Force type: workflow or chat (auto-detected if omitted)')
+    .option('--db <name>', 'Target database (for chat import)')
+    .option('--collection <name>', 'Target collection (for chat import)')
+    .option('--dry-run', 'Show what would be imported without writing')
+    .option('--json', 'Machine-readable JSON output')
+    .action(async (file, opts) => {
+      try {
+        const resolved = path.resolve(file);
+        if (!fs.existsSync(resolved)) {
+          throw new Error(`File not found: ${resolved}`);
+        }
+
+        const raw = fs.readFileSync(resolved, 'utf-8');
+        const data = JSON.parse(raw);
+
+        // Auto-detect type
+        const type = opts.type || detectType(data);
+        if (!type) {
+          throw new Error(
+            'Could not auto-detect import type. Use --type workflow or --type chat.'
+          );
+        }
+
+        if (type === 'workflow') {
+          await importWorkflow(data, opts, resolved);
+        } else if (type === 'chat') {
+          await importChat(data, opts, resolved);
+        } else {
+          throw new Error(`Unknown import type: "${type}". Use "workflow" or "chat".`);
+        }
+      } catch (err) {
+        if (opts.json) {
+          console.log(JSON.stringify({ error: err.message }));
+        } else {
+          console.error(ui.error ? ui.error(err.message) : `✗ ${err.message}`);
+        }
+        process.exitCode = 1;
+      }
+    });
+}
+
+/**
+ * Detect whether the JSON is a workflow or chat session.
+ */
+function detectType(data) {
+  // Workflow: has steps array
+  if (Array.isArray(data.steps) && data.steps.length > 0) return 'workflow';
+  // Chat: has turns or session object with turns
+  if (data.turns || (data.session && data.session.turns)) return 'chat';
+  // Exported chat wrapper
+  if (data._context === 'chat') return 'chat';
+  if (data._context === 'workflow') return 'workflow';
+  // Workflow with name + steps
+  if (data.name && data.steps) return 'workflow';
+  return null;
+}
+
+/**
+ * Import a workflow definition.
+ */
+async function importWorkflow(data, opts, filePath) {
+  // Strip export metadata
+  const workflow = { ...data };
+  delete workflow._exportMeta;
+  delete workflow._metadata;
+  delete workflow._execution;
+  delete workflow._context;
+  delete workflow._dependencyMap;
+  delete workflow._executionLayers;
+
+  // Validate
+  const errors = validateWorkflow(workflow);
+  if (errors.length > 0) {
+    throw new Error(`Invalid workflow:\n  ${errors.join('\n  ')}`);
+  }
+
+  const stepCount = (workflow.steps || []).length;
+  const inputCount = Object.keys(workflow.inputs || {}).length;
+
+  if (opts.dryRun) {
+    const summary = {
+      type: 'workflow',
+      name: workflow.name,
+      version: workflow.version,
+      steps: stepCount,
+      inputs: inputCount,
+      valid: true,
+    };
+    if (opts.json) {
+      console.log(JSON.stringify({ dryRun: true, ...summary }));
+    } else {
+      console.log(ui.success ? ui.success('Dry run — workflow is valid') : '✓ Dry run — workflow is valid');
+      console.log(`  Name: ${workflow.name}`);
+      console.log(`  Version: ${workflow.version || '—'}`);
+      console.log(`  Steps: ${stepCount}`);
+      console.log(`  Inputs: ${inputCount}`);
+    }
+    return;
+  }
+
+  // Write cleaned workflow to a local file
+  const outName = `${workflow.name || 'imported-workflow'}.json`;
+  const outPath = path.resolve(outName);
+  fs.writeFileSync(outPath, JSON.stringify(workflow, null, 2) + '\n', 'utf-8');
+
+  if (opts.json) {
+    console.log(JSON.stringify({ imported: true, type: 'workflow', path: outPath, steps: stepCount }));
+  } else {
+    console.log(ui.success ? ui.success(`Imported workflow → ${outPath}`) : `✓ Imported workflow → ${outPath}`);
+    console.log(`  Name: ${workflow.name}  |  Steps: ${stepCount}  |  Inputs: ${inputCount}`);
+    console.log(`  Run with: vai workflow run ${outName}`);
+  }
+}
+
+/**
+ * Import a chat session into MongoDB.
+ */
+async function importChat(data, opts, filePath) {
+  // Unwrap export format
+  const session = data.session || data;
+  const turns = session.turns || [];
+
+  if (turns.length === 0) {
+    throw new Error('Chat session has no turns to import.');
+  }
+
+  const summary = {
+    type: 'chat',
+    sessionId: session.sessionId || session.id,
+    turns: turns.length,
+    provider: session.provider,
+    model: session.model,
+  };
+
+  if (opts.dryRun) {
+    if (opts.json) {
+      console.log(JSON.stringify({ dryRun: true, ...summary }));
+    } else {
+      console.log(ui.success ? ui.success('Dry run — chat session is valid') : '✓ Dry run — chat session is valid');
+      console.log(`  Session: ${summary.sessionId || '—'}`);
+      console.log(`  Turns: ${summary.turns}`);
+      console.log(`  Provider: ${summary.provider || '—'} (${summary.model || '—'})`);
+    }
+    return;
+  }
+
+  // Import to MongoDB
+  const dbName = opts.db || 'vai';
+  const collName = opts.collection || 'chat_history';
+
+  const { getMongoCollection } = require('../lib/mongo');
+  const { client, collection } = await getMongoCollection(dbName, collName);
+
+  try {
+    const docs = turns.map((turn, i) => ({
+      sessionId: session.sessionId || session.id || `imported-${Date.now()}`,
+      role: turn.role,
+      content: turn.content,
+      timestamp: turn.timestamp ? new Date(turn.timestamp) : new Date(),
+      ...(turn.context ? { context: turn.context } : {}),
+      ...(turn.metadata ? { metadata: turn.metadata } : {}),
+      _imported: true,
+      _importedAt: new Date(),
+      _importSource: path.basename(filePath),
+    }));
+
+    const result = await collection.insertMany(docs);
+
+    if (opts.json) {
+      console.log(JSON.stringify({ imported: true, ...summary, inserted: result.insertedCount, db: dbName, collection: collName }));
+    } else {
+      console.log(ui.success ? ui.success(`Imported ${result.insertedCount} turns → ${dbName}.${collName}`) : `✓ Imported ${result.insertedCount} turns → ${dbName}.${collName}`);
+      console.log(`  Session: ${summary.sessionId || '—'}  |  Provider: ${summary.provider || '—'}`);
+    }
+  } finally {
+    await client.close();
+  }
+}
+
+module.exports = { registerImport, detectType };

package/src/commands/index-workspace.js

@@ -0,0 +1,239 @@
+'use strict';
+
+const path = require('path');
+const ora = require('ora');
+const pc = require('picocolors');
+
+/**
+ * Register the index-workspace command.
+ * @param {import('commander').Command} program
+ */
+function registerIndexWorkspace(program) {
+  program
+    .command('index-workspace [path]')
+    .alias('index-ws')
+    .description('Index a workspace/codebase for semantic code search')
+    .option('--db <name>', 'MongoDB database name')
+    .option('--collection <name>', 'Collection to store indexed documents')
+    .option('--content-type <type>', 'Content type: code, docs, config, or all', 'code')
+    .option('--model <name>', 'Embedding model', 'voyage-code-3')
+    .option('--max-files <n>', 'Maximum files to index', (v) => parseInt(v, 10), 1000)
+    .option('--max-file-size <bytes>', 'Maximum file size in bytes', (v) => parseInt(v, 10), 100000)
+    .option('--chunk-size <n>', 'Target chunk size in characters', (v) => parseInt(v, 10), 512)
+    .option('--chunk-overlap <n>', 'Overlap between chunks', (v) => parseInt(v, 10), 50)
+    .option('--batch-size <n>', 'Files per batch', (v) => parseInt(v, 10), 10)
+    .option('--create-index', 'Create vector search index after indexing')
+    .option('--json', 'Output as JSON')
+    .action(async (workspacePath, opts) => {
+      const telemetry = require('../lib/telemetry');
+      telemetry.send('cli_index_workspace_run', { contentType: opts.contentType });
+
+      const { handleIndexWorkspace } = require('../mcp/tools/workspace');
+      const resolvedPath = workspacePath ? path.resolve(workspacePath) : process.cwd();
+
+      const spinner = ora(`Indexing ${resolvedPath}...`).start();
+
+      try {
+        const result = await handleIndexWorkspace({
+          path: resolvedPath,
+          db: opts.db,
+          collection: opts.collection,
+          contentType: opts.contentType,
+          model: opts.model,
+          maxFiles: opts.maxFiles,
+          maxFileSize: opts.maxFileSize,
+          chunkSize: opts.chunkSize,
+          chunkOverlap: opts.chunkOverlap,
+          batchSize: opts.batchSize,
+        });
+
+        spinner.stop();
+
+        if (opts.json) {
+          console.log(JSON.stringify(result.structuredContent, null, 2));
+        } else {
+          const stats = result.structuredContent;
+          console.log('\n' + pc.green('Workspace indexed successfully!') + '\n');
+          console.log(`  Files found:    ${stats.filesFound}`);
+          console.log(`  Files indexed:  ${stats.filesIndexed}`);
+          console.log(`  Chunks created: ${stats.chunksCreated}`);
+          console.log(`  Time:           ${stats.timeMs}ms`);
+          console.log(`  Collection:     ${stats.db}.${stats.collection}`);
+          console.log(`  Model:          ${stats.model}`);
+
+          if (stats.errors?.length > 0) {
+            console.log('\n' + pc.yellow(`Errors (${stats.errors.length}):`));
+            for (const err of stats.errors.slice(0, 5)) {
+              console.log(`  ${pc.dim(err.file)}: ${err.error}`);
+            }
+            if (stats.errors.length > 5) {
+              console.log(`  ... and ${stats.errors.length - 5} more`);
+            }
+          }
+        }
+
+        // Create index if requested
+        if (opts.createIndex) {
+          const indexSpinner = ora('Creating vector search index...').start();
+          try {
+            const { createVectorIndex } = require('../lib/mongo');
+            await createVectorIndex(
+              result.structuredContent.db,
+              result.structuredContent.collection,
+              'vector_index',
+              'embedding'
+            );
+            indexSpinner.succeed('Vector search index created');
+          } catch (err) {
+            indexSpinner.fail(`Failed to create index: ${err.message}`);
+          }
+        }
+
+      } catch (err) {
+        spinner.fail(`Indexing failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // Search code command
+  program
+    .command('search-code <query>')
+    .alias('sc')
+    .description('Semantic code search across indexed codebase')
+    .option('--db <name>', 'MongoDB database name')
+    .option('--collection <name>', 'Collection with indexed code')
+    .option('--limit <n>', 'Maximum results', (v) => parseInt(v, 10), 10)
+    .option('--language <lang>', 'Filter by programming language (e.g., js, py, go)')
+    .option('--category <cat>', 'Filter by category: code, docs, config')
+    .option('--model <name>', 'Embedding model')
+    .option('--json', 'Output as JSON')
+    .action(async (query, opts) => {
+      const telemetry = require('../lib/telemetry');
+      telemetry.send('cli_search_code_run', { language: opts.language });
+
+      const { handleSearchCode } = require('../mcp/tools/workspace');
+      const spinner = ora('Searching...').start();
+
+      try {
+        const result = await handleSearchCode({
+          query,
+          db: opts.db,
+          collection: opts.collection,
+          limit: opts.limit,
+          language: opts.language,
+          category: opts.category,
+          model: opts.model,
+        });
+
+        spinner.stop();
+
+        if (opts.json) {
+          console.log(JSON.stringify(result.structuredContent, null, 2));
+        } else {
+          const results = result.structuredContent.results;
+          const meta = result.structuredContent.metadata;
+
+          console.log(`\n${pc.bold(`Found ${results.length} results`)} ${pc.dim(`(${meta.timeMs}ms)`)}\n`);
+
+          for (let i = 0; i < results.length; i++) {
+            const r = results[i];
+            const score = (r.score * 100).toFixed(1);
+
+            console.log(pc.cyan(`[${i + 1}] ${r.source}`) + pc.dim(` (${r.language || 'unknown'}) — ${score}%`));
+
+            if (r.symbols?.length > 0) {
+              console.log(pc.dim(`    Symbols: ${r.symbols.slice(0, 5).join(', ')}`));
+            }
+
+            // Show snippet
+            const snippet = r.content.slice(0, 200).replace(/\n/g, '\n    ');
+            console.log(pc.dim('    ' + snippet + (r.content.length > 200 ? '...' : '')));
+            console.log('');
+          }
+        }
+
+      } catch (err) {
+        spinner.fail(`Search failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // Explain code command (context retrieval for code)
+  program
+    .command('context-code')
+    .alias('ctx')
+    .description('Get contextual information for code from indexed documentation')
+    .option('--code <snippet>', 'Code snippet to explain')
+    .option('--file <path>', 'File containing code to explain')
+    .option('--language <lang>', 'Programming language')
+    .option('--db <name>', 'MongoDB database name')
+    .option('--collection <name>', 'Collection with indexed documentation')
+    .option('--context-limit <n>', 'Number of context documents', (v) => parseInt(v, 10), 5)
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+      const telemetry = require('../lib/telemetry');
+      telemetry.send('cli_explain_code_run');
+
+      const { handleExplainCode } = require('../mcp/tools/workspace');
+      const fs = require('fs');
+
+      let code = opts.code;
+
+      // Read from file if provided
+      if (opts.file && !code) {
+        try {
+          code = fs.readFileSync(opts.file, 'utf-8');
+          if (!opts.language) {
+            opts.language = path.extname(opts.file).slice(1);
+          }
+        } catch (err) {
+          console.error(`Failed to read file: ${err.message}`);
+          process.exit(1);
+        }
+      }
+
+      // Read from stdin if no code provided
+      if (!code) {
+        console.error('Provide code via --code, --file, or pipe to stdin');
+        process.exit(1);
+      }
+
+      const spinner = ora('Finding relevant context...').start();
+
+      try {
+        const result = await handleExplainCode({
+          code,
+          language: opts.language,
+          db: opts.db,
+          collection: opts.collection,
+          contextLimit: opts.contextLimit,
+        });
+
+        spinner.stop();
+
+        if (opts.json) {
+          console.log(JSON.stringify(result.structuredContent, null, 2));
+        } else {
+          console.log('\n' + pc.bold('Code Context') + '\n');
+          console.log(pc.dim('─'.repeat(60)) + '\n');
+
+          const context = result.structuredContent.context || [];
+          if (context.length === 0) {
+            console.log(pc.yellow('No relevant context found. Try indexing more documentation.'));
+          } else {
+            for (const ctx of context) {
+              console.log(pc.cyan(`[${ctx.source}]`) + pc.dim(` — ${(ctx.score * 100).toFixed(1)}%`));
+              console.log(ctx.content.slice(0, 500));
+              console.log(pc.dim('─'.repeat(40)) + '\n');
+            }
+          }
+        }
+
+      } catch (err) {
+        spinner.fail(`Explain failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}
+
+module.exports = { registerIndexWorkspace };