voyageai-cli 1.29.0 → 1.30.1

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

package/src/commands/ingest.js

@@ -208,6 +208,8 @@ function registerIngest(program) {
     .option('--json', 'Machine-readable JSON output')
     .option('-q, --quiet', 'Suppress progress, show only final summary')
     .action(async (opts) => {
+      const telemetry = require('../lib/telemetry');
+      const done = telemetry.timer('cli_ingest');
       const startTime = Date.now();
 
       // Validate file exists
@@ -394,7 +396,9 @@ function registerIngest(program) {
             }
           }
         }
+        done({ format, docCount: succeeded });
       } catch (err) {
+        telemetry.send('cli_error', { command: 'ingest', errorType: err.constructor.name });
         console.error(ui.error(err.message));
         process.exit(1);
       } finally {

package/src/commands/init.js

@@ -21,6 +21,8 @@ function registerInit(program) {
     .option('--json', 'Output created config as JSON (non-interactive)')
     .option('-q, --quiet', 'Suppress non-essential output')
     .action(async (opts) => {
+      const telemetry = require('../lib/telemetry');
+      telemetry.send('cli_init');
       // Check for existing config
       const existing = findProjectFile();
       if (existing && !opts.force) {

package/src/commands/mcp-server.js

@@ -17,6 +17,8 @@ function registerMcpServer(program) {
     .option('--no-sse', 'Disable SSE transport (SSE is enabled by default for HTTP)')
     .option('--verbose', 'Enable debug logging to stderr')
     .action(async (opts) => {
+      const telemetry = require('../lib/telemetry');
+      telemetry.send('cli_mcp_start', { transport: opts.transport });
       if (opts.verbose) {
         process.env.VAI_MCP_VERBOSE = '1';
       }
@@ -51,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 {
@@ -74,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}`);
         }
@@ -121,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/models.js

@@ -46,6 +46,8 @@ function registerModels(program) {
     .option('--json', 'Machine-readable JSON output')
     .option('-q, --quiet', 'Suppress non-essential output')
     .action((opts) => {
+      const telemetry = require('../lib/telemetry');
+      telemetry.send('cli_models', { category: opts.type });
       let models = MODEL_CATALOG;
 
       // Separate current and legacy models

package/src/commands/ping.js

@@ -15,6 +15,7 @@ function registerPing(program) {
     .option('-q, --quiet', 'Suppress non-essential output')
     .option('--mask', 'Mask sensitive info (cluster hostnames, endpoints) in output. Also enabled by VAI_MASK=1 env var.')
     .action(async (opts) => {
+      const telemetry = require('../lib/telemetry');
       // Support env var so all recordings are masked without remembering the flag
       if (process.env.VAI_MASK === '1' || process.env.VAI_MASK === 'true') {
         opts.mask = true;
@@ -242,6 +243,12 @@ function registerPing(program) {
         }
       }
 
+      // Telemetry
+      telemetry.send('cli_ping', {
+        voyageOk: !!results.voyage?.ok,
+        mongoOk: !!results.mongodb?.ok,
+      });
+
       // Emit JSON at the end with all results
       if (opts.json) {
         console.log(JSON.stringify({ ok: true, ...results }, null, 2));

package/src/commands/pipeline.js

@@ -67,6 +67,7 @@ function registerPipeline(program) {
     .option('-q, --quiet', 'Suppress non-essential output')
     .action(async (input, opts) => {
       let client;
+      const telemetry = require('../lib/telemetry');
       try {
         // Merge project config
         const { config: proj } = loadProject();
@@ -89,6 +90,13 @@ function registerPipeline(program) {
           process.exit(1);
         }
 
+        const done = telemetry.timer('cli_pipeline', {
+          model,
+          chunkStrategy: strategy,
+          chunkSize,
+          createIndex: !!opts.createIndex,
+        });
+
         if (!STRATEGIES.includes(strategy)) {
           console.error(ui.error(`Unknown strategy: "${strategy}". Available: ${STRATEGIES.join(', ')}`));
           process.exit(1);
@@ -313,7 +321,14 @@ function registerPipeline(program) {
           console.log('');
           console.log(ui.dim('  Next: vai query "your search" --db ' + db + ' --collection ' + collection));
         }
+
+        done({
+          fileCount: files.length,
+          chunkCount: allChunks.length,
+          docCount: insertResult.insertedCount,
+        });
       } catch (err) {
+        telemetry.send('cli_error', { command: 'pipeline', errorType: err.constructor.name });
         console.error(ui.error(err.message));
         process.exit(1);
       } finally {