voyageai-cli 1.4.0 → 1.6.0

package/src/commands/models.js

@@ -1,10 +1,36 @@
 'use strict';
 
 const { MODEL_CATALOG } = require('../lib/catalog');
-const { API_BASE } = require('../lib/api');
+const { getApiBase } = require('../lib/api');
 const { formatTable } = require('../lib/format');
 const ui = require('../lib/ui');
 
+/**
+ * Shorten dimensions string for compact display.
+ * "1024 (default), 256, 512, 2048" → "1024*"
+ * "1024" → "1024"
+ * "—" → "—"
+ * @param {string} dims
+ * @returns {string}
+ */
+function compactDimensions(dims) {
+  if (dims === '—') return dims;
+  const match = dims.match(/^(\d+)\s*\(default\)/);
+  if (match) return match[1] + '*';
+  return dims;
+}
+
+/**
+ * Shorten price string for compact display.
+ * "$0.12/1M tokens" → "$0.12/1M"
+ * "$0.12/M + $0.60/B px" → "$0.12/M+$0.60/Bpx"
+ * @param {string} price
+ * @returns {string}
+ */
+function compactPrice(price) {
+  return price.replace('/1M tokens', '/1M').replace(' + ', '+').replace('/B px', '/Bpx');
+}
+
 /**
  * Register the models command on a Commander program.
  * @param {import('commander').Command} program
@@ -14,15 +40,26 @@ function registerModels(program) {
     .command('models')
     .description('List available Voyage AI models')
     .option('-t, --type <type>', 'Filter by type: embedding, reranking, or all', 'all')
+    .option('-a, --all', 'Show all models including legacy')
+    .option('-w, --wide', 'Wide output (show all columns untruncated)')
     .option('--json', 'Machine-readable JSON output')
     .option('-q, --quiet', 'Suppress non-essential output')
     .action((opts) => {
       let models = MODEL_CATALOG;
 
+      // Separate current and legacy models
+      const showLegacy = opts.all;
+      const currentModels = models.filter(m => !m.legacy);
+      const legacyModels = models.filter(m => m.legacy);
+
       if (opts.type !== 'all') {
         models = models.filter(m => m.type === opts.type);
       }
 
+      if (!showLegacy) {
+        models = models.filter(m => !m.legacy);
+      }
+
       if (opts.json) {
         console.log(JSON.stringify(models, null, 2));
         return;
@@ -33,28 +70,69 @@ function registerModels(program) {
         return;
       }
 
+      const apiBase = getApiBase();
+
       if (!opts.quiet) {
         console.log(ui.bold('Voyage AI Models'));
-        console.log(ui.dim(`(via MongoDB AI API — ${API_BASE})`));
+        console.log(ui.dim(`(via ${apiBase})`));
         console.log('');
       }
 
-      const headers = ['Model', 'Type', 'Context', 'Dimensions', 'Price', 'Best For'];
-      const rows = models.map(m => {
+      // Split models for display
+      const displayCurrent = models.filter(m => !m.legacy);
+      const displayLegacy = models.filter(m => m.legacy);
+
+      const formatWideRow = (m) => {
         const name = ui.cyan(m.name);
         const type = m.type === 'embedding' ? ui.green(m.type) : ui.yellow(m.type);
         const price = ui.dim(m.price);
         return [name, type, m.context, m.dimensions, price, m.bestFor];
-      });
+      };
 
-      // Use bold headers
-      const boldHeaders = headers.map(h => ui.bold(h));
-      console.log(formatTable(boldHeaders, rows));
+      const formatCompactRow = (m) => {
+        const name = ui.cyan(m.name);
+        const type = m.type === 'embedding' ? ui.green('embed') : ui.yellow('rerank');
+        const dims = compactDimensions(m.dimensions);
+        const price = ui.dim(compactPrice(m.price));
+        return [name, type, dims, price, m.shortFor || m.bestFor];
+      };
+
+      if (opts.wide) {
+        const headers = ['Model', 'Type', 'Context', 'Dimensions', 'Price', 'Best For'];
+        const boldHeaders = headers.map(h => ui.bold(h));
+        const rows = displayCurrent.map(formatWideRow);
+        console.log(formatTable(boldHeaders, rows));
+
+        if (showLegacy && displayLegacy.length > 0) {
+          console.log('');
+          console.log(ui.dim('Legacy Models (use latest for better quality)'));
+          const legacyRows = displayLegacy.map(formatWideRow);
+          console.log(formatTable(boldHeaders, legacyRows));
+        }
+      } else {
+        const headers = ['Model', 'Type', 'Dims', 'Price', 'Use Case'];
+        const boldHeaders = headers.map(h => ui.bold(h));
+        const rows = displayCurrent.map(formatCompactRow);
+        console.log(formatTable(boldHeaders, rows));
+
+        if (showLegacy && displayLegacy.length > 0) {
+          console.log('');
+          console.log(ui.dim('Legacy Models (use latest for better quality)'));
+          const legacyRows = displayLegacy.map(formatCompactRow);
+          console.log(formatTable(boldHeaders, legacyRows));
+        }
+      }
 
       if (!opts.quiet) {
         console.log('');
+        if (!opts.wide) {
+          console.log(ui.dim('* = also supports 256, 512, 2048 dimensions'));
+        }
         console.log(ui.dim('Free tier: 200M tokens (most models), 50M (domain-specific)'));
         console.log(ui.dim('All 4-series models share the same embedding space.'));
+        if (!opts.wide) {
+          console.log(ui.dim('Use --wide for full details.'));
+        }
       }
     });
 }

package/src/commands/ping.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { API_BASE, requireApiKey } = require('../lib/api');
+const { getApiBase, requireApiKey } = require('../lib/api');
 const ui = require('../lib/ui');
 
 /**
@@ -28,6 +28,7 @@ function registerPing(program) {
       const useColor = !opts.json;
       const useSpinner = useColor && !opts.quiet;
 
+      const apiBase = getApiBase();
       const model = 'voyage-4-lite';
       const startTime = Date.now();
 
@@ -38,7 +39,7 @@ function registerPing(program) {
       }
 
       try {
-        const response = await fetch(`${API_BASE}/embeddings`, {
+        const response = await fetch(`${apiBase}/embeddings`, {
           method: 'POST',
           headers: {
             'Content-Type': 'application/json',
@@ -83,7 +84,7 @@ function registerPing(program) {
         const dims = data.data && data.data[0] ? data.data[0].embedding.length : 'unknown';
         const tokens = data.usage ? data.usage.total_tokens : 'unknown';
 
-        results.voyage = { ok: true, elapsed, model, dimensions: dims, tokens, endpoint: API_BASE };
+        results.voyage = { ok: true, elapsed, model, dimensions: dims, tokens, endpoint: apiBase };
 
         if (spin) spin.stop();
 
@@ -93,7 +94,7 @@ function registerPing(program) {
           console.log(`ok ${elapsed}ms`);
         } else {
           console.log(ui.success(`Connected to Voyage AI API ${ui.dim('(' + elapsed + 'ms)')}`));
-          console.log(ui.label('Endpoint', API_BASE));
+          console.log(ui.label('Endpoint', apiBase));
           console.log(ui.label('Model', model));
           console.log(ui.label('Dimensions', String(dims)));
           console.log(ui.label('Tokens', String(tokens)));

package/src/commands/rerank.js

@@ -18,6 +18,9 @@ function registerRerank(program) {
     .option('--documents-file <path>', 'File with documents (JSON array or newline-delimited)')
     .option('-m, --model <model>', 'Reranking model', DEFAULT_RERANK_MODEL)
     .option('-k, --top-k <n>', 'Return top K results', (v) => parseInt(v, 10))
+    .option('--truncation', 'Enable truncation for long inputs')
+    .option('--no-truncation', 'Disable truncation')
+    .option('--return-documents', 'Return document text in results')
     .option('--json', 'Machine-readable JSON output')
     .option('-q, --quiet', 'Suppress non-essential output')
     .action(async (opts) => {
@@ -76,6 +79,12 @@ function registerRerank(program) {
         if (opts.topK) {
           body.top_k = opts.topK;
         }
+        if (opts.truncation !== undefined) {
+          body.truncation = opts.truncation;
+        }
+        if (opts.returnDocuments) {
+          body.return_documents = true;
+        }
 
         const useColor = !opts.json;
         const useSpinner = useColor && !opts.quiet;
@@ -106,8 +115,9 @@ function registerRerank(program) {
 
         if (result.data) {
           for (const item of result.data) {
-            const docPreview = documents[item.index].substring(0, 80);
-            const ellipsis = documents[item.index].length > 80 ? '...' : '';
+            const docText = item.document || documents[item.index];
+            const docPreview = docText.substring(0, 80);
+            const ellipsis = docText.length > 80 ? '...' : '';
             console.log(`${ui.dim('[' + item.index + ']')} Score: ${ui.score(item.relevance_score)}  ${ui.dim('"' + docPreview + ellipsis + '"')}`);
           }
         }

package/src/lib/api.js

@@ -1,8 +1,32 @@
 'use strict';
 
-const API_BASE = 'https://ai.mongodb.com/v1';
+const ATLAS_API_BASE = 'https://ai.mongodb.com/v1';
+const VOYAGE_API_BASE = 'https://api.voyageai.com/v1';
 const MAX_RETRIES = 3;
 
+/**
+ * Resolve the API base URL.
+ * Priority: VOYAGE_API_BASE env → config baseUrl → auto-detect from key prefix.
+ * Keys starting with 'pa-' that work on Voyage platform use VOYAGE_API_BASE.
+ * @returns {string}
+ */
+function getApiBase() {
+  const { getConfigValue } = require('./config');
+
+  // Explicit override wins
+  const envBase = process.env.VOYAGE_API_BASE;
+  if (envBase) return envBase.replace(/\/+$/, '');
+
+  const configBase = getConfigValue('baseUrl');
+  if (configBase) return configBase.replace(/\/+$/, '');
+
+  // Default to Atlas endpoint
+  return ATLAS_API_BASE;
+}
+
+// Legacy export for backward compat
+const API_BASE = ATLAS_API_BASE;
+
 /**
  * Get the Voyage API key or exit with a helpful error.
  * Checks: env var → config file.
@@ -18,6 +42,7 @@ function requireApiKey() {
     console.error('Option 2: vai config set api-key <your-key>');
     console.error('');
     console.error('Get one from MongoDB Atlas → AI Models → Create model API key');
+    console.error('       or Voyage AI platform → Dashboard → API Keys');
     process.exit(1);
   }
   return key;
@@ -40,7 +65,8 @@ function sleep(ms) {
  */
 async function apiRequest(endpoint, body) {
   const apiKey = requireApiKey();
-  const url = `${API_BASE}${endpoint}`;
+  const base = getApiBase();
+  const url = `${base}${endpoint}`;
 
   for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
     const response = await fetch(url, {
@@ -69,6 +95,23 @@ async function apiRequest(endpoint, body) {
         errorDetail = await response.text();
       }
       console.error(`API Error (${response.status}): ${errorDetail}`);
+
+      // Help users diagnose endpoint mismatch
+      if (response.status === 403 && base === ATLAS_API_BASE) {
+        console.error('');
+        console.error('Hint: 403 on ai.mongodb.com often means your key is for the Voyage AI');
+        console.error('platform, not MongoDB Atlas. Try switching the base URL:');
+        console.error('');
+        console.error('  vai config set base-url https://api.voyageai.com/v1/');
+        console.error('');
+        console.error('Or set VOYAGE_API_BASE=https://api.voyageai.com/v1/ in your environment.');
+      } else if (response.status === 401 && base === VOYAGE_API_BASE) {
+        console.error('');
+        console.error('Hint: 401 on api.voyageai.com may mean your key is an Atlas AI key.');
+        console.error('Try switching back:');
+        console.error('');
+        console.error('  vai config set base-url https://ai.mongodb.com/v1/');
+      }
       process.exit(1);
     }
 
@@ -83,6 +126,7 @@ async function apiRequest(endpoint, body) {
  * @param {string} [options.model] - Model name
  * @param {string} [options.inputType] - Input type (query|document)
  * @param {number} [options.dimensions] - Output dimensions
+ * @param {boolean} [options.truncation] - Enable/disable truncation
  * @returns {Promise<object>} API response with embeddings
  */
 async function generateEmbeddings(texts, options = {}) {
@@ -99,12 +143,18 @@ async function generateEmbeddings(texts, options = {}) {
   if (options.dimensions) {
     body.output_dimension = options.dimensions;
   }
+  if (options.truncation !== undefined) {
+    body.truncation = options.truncation;
+  }
 
   return apiRequest('/embeddings', body);
 }
 
 module.exports = {
   API_BASE,
+  ATLAS_API_BASE,
+  VOYAGE_API_BASE,
+  getApiBase,
   requireApiKey,
   apiRequest,
   generateEmbeddings,

package/src/lib/catalog.js

@@ -24,16 +24,25 @@ function getDefaultDimensions() {
 
 /** @type {Array<{name: string, type: string, context: string, dimensions: string, price: string, bestFor: string}>} */
 const MODEL_CATALOG = [
-  { name: 'voyage-4-large', type: 'embedding', context: '32K', dimensions: '1024 (default), 256, 512, 2048', price: '$0.12/1M tokens', bestFor: 'Best quality, multilingual' },
-  { name: 'voyage-4', type: 'embedding', context: '32K', dimensions: '1024 (default), 256, 512, 2048', price: '$0.06/1M tokens', bestFor: 'Balanced quality/perf' },
-  { name: 'voyage-4-lite', type: 'embedding', context: '32K', dimensions: '1024 (default), 256, 512, 2048', price: '$0.02/1M tokens', bestFor: 'Lowest cost' },
-  { name: 'voyage-code-3', type: 'embedding', context: '32K', dimensions: '1024 (default), 256, 512, 2048', price: '$0.18/1M tokens', bestFor: 'Code retrieval' },
-  { name: 'voyage-finance-2', type: 'embedding', context: '32K', dimensions: '1024', price: '$0.12/1M tokens', bestFor: 'Finance' },
-  { name: 'voyage-law-2', type: 'embedding', context: '16K', dimensions: '1024', price: '$0.12/1M tokens', bestFor: 'Legal' },
-  { name: 'voyage-context-3', type: 'embedding', context: '32K', dimensions: '1024 (default), 256, 512, 2048', price: '$0.18/1M tokens', bestFor: 'Contextualized chunks' },
-  { name: 'voyage-multimodal-3.5', type: 'embedding', context: '32K', dimensions: '1024 (default), 256, 512, 2048', price: '$0.12/M + $0.60/B px', bestFor: 'Text + images + video' },
-  { name: 'rerank-2.5', type: 'reranking', context: '32K', dimensions: '—', price: '$0.05/1M tokens', bestFor: 'Best quality reranking' },
-  { name: 'rerank-2.5-lite', type: 'reranking', context: '32K', dimensions: '—', price: '$0.02/1M tokens', bestFor: 'Fast reranking' },
+  { name: 'voyage-4-large', type: 'embedding', context: '32K', dimensions: '1024 (default), 256, 512, 2048', price: '$0.12/1M tokens', bestFor: 'Best quality, multilingual', shortFor: 'Best quality' },
+  { name: 'voyage-4', type: 'embedding', context: '32K', dimensions: '1024 (default), 256, 512, 2048', price: '$0.06/1M tokens', bestFor: 'Balanced quality/perf', shortFor: 'Balanced' },
+  { name: 'voyage-4-lite', type: 'embedding', context: '32K', dimensions: '1024 (default), 256, 512, 2048', price: '$0.02/1M tokens', bestFor: 'Lowest cost', shortFor: 'Budget' },
+  { name: 'voyage-code-3', type: 'embedding', context: '32K', dimensions: '1024 (default), 256, 512, 2048', price: '$0.18/1M tokens', bestFor: 'Code retrieval', shortFor: 'Code' },
+  { name: 'voyage-finance-2', type: 'embedding', context: '32K', dimensions: '1024', price: '$0.12/1M tokens', bestFor: 'Finance', shortFor: 'Finance' },
+  { name: 'voyage-law-2', type: 'embedding', context: '16K', dimensions: '1024', price: '$0.12/1M tokens', bestFor: 'Legal', shortFor: 'Legal' },
+  { name: 'voyage-context-3', type: 'embedding', context: '32K', dimensions: '1024 (default), 256, 512, 2048', price: '$0.18/1M tokens', bestFor: 'Contextualized chunks', shortFor: 'Context chunks' },
+  { name: 'voyage-multimodal-3.5', type: 'embedding', context: '32K', dimensions: '1024 (default), 256, 512, 2048', price: '$0.12/M + $0.60/B px', bestFor: 'Text + images + video', shortFor: 'Multimodal' },
+  { name: 'rerank-2.5', type: 'reranking', context: '32K', dimensions: '—', price: '$0.05/1M tokens', bestFor: 'Best quality reranking', shortFor: 'Best reranker' },
+  { name: 'rerank-2.5-lite', type: 'reranking', context: '32K', dimensions: '—', price: '$0.02/1M tokens', bestFor: 'Fast reranking', shortFor: 'Fast reranker' },
+  { name: 'voyage-4-nano', type: 'embedding', context: '32K', dimensions: '512 (default), 128, 256', price: 'Open-weight', bestFor: 'Open-weight / edge', shortFor: 'Open / edge' },
+  // Legacy models
+  { name: 'voyage-3-large', type: 'embedding', context: '32K', dimensions: '1024 (default), 256, 512, 2048', price: '$0.18/1M tokens', bestFor: 'Previous gen quality', shortFor: 'Previous gen quality', legacy: true },
+  { name: 'voyage-3.5', type: 'embedding', context: '32K', dimensions: '1024 (default), 256, 512, 2048', price: '$0.06/1M tokens', bestFor: 'Previous gen balanced', shortFor: 'Previous gen balanced', legacy: true },
+  { name: 'voyage-3.5-lite', type: 'embedding', context: '32K', dimensions: '1024 (default), 256, 512, 2048', price: '$0.02/1M tokens', bestFor: 'Previous gen budget', shortFor: 'Previous gen budget', legacy: true },
+  { name: 'voyage-code-2', type: 'embedding', context: '16K', dimensions: '1536', price: '$0.12/1M tokens', bestFor: 'Legacy code', shortFor: 'Legacy code', legacy: true },
+  { name: 'voyage-multimodal-3', type: 'embedding', context: '32K', dimensions: '1024', price: '$0.12/1M tokens', bestFor: 'Legacy multimodal', shortFor: 'Legacy multimodal', legacy: true },
+  { name: 'rerank-2', type: 'reranking', context: '16K', dimensions: '—', price: '$0.05/1M tokens', bestFor: 'Legacy reranker', shortFor: 'Legacy reranker', legacy: true },
+  { name: 'rerank-2-lite', type: 'reranking', context: '8K', dimensions: '—', price: '$0.02/1M tokens', bestFor: 'Legacy fast reranker', shortFor: 'Legacy fast reranker', legacy: true },
 ];
 
 module.exports = {

package/src/lib/config.js

@@ -13,6 +13,7 @@ const KEY_MAP = {
   'mongodb-uri': 'mongodbUri',
   'default-model': 'defaultModel',
   'default-dimensions': 'defaultDimensions',
+  'base-url': 'baseUrl',
 };
 
 // Keys whose values should be masked in output

package/src/lib/explanations.js

@@ -210,12 +210,15 @@ const concepts = {
       `The ${pc.cyan('input_type')} parameter tells the embedding model whether the text is a`,
       `${pc.cyan('search query')} or a ${pc.cyan('document')} being indexed. This matters for retrieval quality.`,
       ``,
-      `${pc.bold('How it works:')} Voyage AI models internally prepend a short prompt to your text`,
-      `based on input_type:`,
-      `  ${pc.dim('• query →')}    "Represent the query for retrieving relevant documents: "`,
-      `  ${pc.dim('• document →')} "Represent the document for retrieval: "`,
+      `${pc.bold('⚠ Do not omit this parameter for retrieval tasks.')} The official docs emphasize`,
+      `that omitting input_type degrades retrieval accuracy.`,
       ``,
-      `These prompts bias the embedding to be ${pc.cyan('asymmetric')} — query embeddings are`,
+      `${pc.bold('How it works:')} Voyage AI models internally prepend a specific prompt prefix`,
+      `to your text based on input_type:`,
+      `  ${pc.dim('• query →')}    ${pc.cyan('"Represent the query for retrieving supporting documents: "')}`,
+      `  ${pc.dim('• document →')} ${pc.cyan('"Represent the document for retrieval: "')}`,
+      ``,
+      `These prefixes bias the embedding to be ${pc.cyan('asymmetric')} — query embeddings are`,
       `optimized to find relevant documents, and document embeddings are optimized`,
       `to be found by relevant queries.`,
       ``,
@@ -226,10 +229,10 @@ const concepts = {
       `${pc.bold('When to use each:')}`,
       `  ${pc.cyan('query')}    — When embedding a search query or question`,
       `  ${pc.cyan('document')} — When embedding text to be stored and searched later`,
-      `  ${pc.dim('(omit)')}   — For clustering, classification, or symmetric similarity`,
+      `  ${pc.dim('(omit)')}   — Only for clustering, classification, or symmetric similarity`,
       ``,
-      `${pc.bold('Tip:')} Always use ${pc.cyan('--input-type document')} when running ${pc.cyan('vai store')}, and`,
-      `${pc.cyan('--input-type query')} is the default for ${pc.cyan('vai search')}.`,
+      `${pc.bold('Tip:')} Always use ${pc.cyan('--input-type document')} when running ${pc.cyan('vai store')} or`,
+      `${pc.cyan('vai ingest')}, and ${pc.cyan('--input-type query')} when running ${pc.cyan('vai search')}.`,
     ].join('\n'),
     links: ['https://www.mongodb.com/docs/voyageai/models/text-embeddings/'],
     tryIt: [

package/test/commands/completions.test.js

@@ -0,0 +1,166 @@
+'use strict';
+
+const { describe, it, beforeEach, afterEach } = require('node:test');
+const assert = require('node:assert/strict');
+const { Command } = require('commander');
+const { registerCompletions, generateBashCompletions, generateZshCompletions } = require('../../src/commands/completions');
+
+describe('completions command', () => {
+  let originalLog;
+  let originalWrite;
+  let originalError;
+  let originalExit;
+  let output;
+  let stdoutOutput;
+  let stderrOutput;
+
+  beforeEach(() => {
+    originalLog = console.log;
+    originalWrite = process.stdout.write;
+    originalError = console.error;
+    originalExit = process.exit;
+    output = [];
+    stdoutOutput = [];
+    stderrOutput = [];
+    console.log = (...args) => output.push(args.join(' '));
+    process.stdout.write = (data) => { stdoutOutput.push(data); return true; };
+    console.error = (...args) => stderrOutput.push(args.join(' '));
+    process.exit = (code) => { throw new Error(`EXIT_${code}`); };
+  });
+
+  afterEach(() => {
+    console.log = originalLog;
+    process.stdout.write = originalWrite;
+    console.error = originalError;
+    process.exit = originalExit;
+  });
+
+  it('registers correctly on a program', () => {
+    const program = new Command();
+    registerCompletions(program);
+    const cmd = program.commands.find(c => c.name() === 'completions');
+    assert.ok(cmd, 'completions command should be registered');
+    assert.ok(cmd.description().includes('completion'), 'should have a description about completions');
+  });
+
+  it('shows usage when called without shell argument', async () => {
+    const program = new Command();
+    program.exitOverride();
+    registerCompletions(program);
+
+    await program.parseAsync(['node', 'test', 'completions']);
+
+    const combined = output.join('\n');
+    assert.ok(combined.includes('bash'), 'should mention bash');
+    assert.ok(combined.includes('zsh'), 'should mention zsh');
+  });
+
+  it('outputs bash completion script', async () => {
+    const program = new Command();
+    program.exitOverride();
+    registerCompletions(program);
+
+    await program.parseAsync(['node', 'test', 'completions', 'bash']);
+
+    const combined = stdoutOutput.join('');
+    assert.ok(combined.includes('_vai_completions'), 'should contain bash completion function');
+    assert.ok(combined.includes('complete -F _vai_completions vai'), 'should register completion');
+  });
+
+  it('outputs zsh completion script', async () => {
+    const program = new Command();
+    program.exitOverride();
+    registerCompletions(program);
+
+    await program.parseAsync(['node', 'test', 'completions', 'zsh']);
+
+    const combined = stdoutOutput.join('');
+    assert.ok(combined.includes('#compdef vai'), 'should contain zsh compdef header');
+    assert.ok(combined.includes('_vai'), 'should contain zsh completion function');
+  });
+
+  it('rejects unknown shell', async () => {
+    const program = new Command();
+    program.exitOverride();
+    registerCompletions(program);
+
+    await assert.rejects(
+      () => program.parseAsync(['node', 'test', 'completions', 'fish']),
+      /EXIT_1/,
+      'should exit with code 1 for unsupported shell'
+    );
+    const combined = stderrOutput.join('\n');
+    assert.ok(combined.includes('fish'), 'should mention the unknown shell name');
+  });
+});
+
+describe('generateBashCompletions', () => {
+  it('includes all 14 commands (including completions)', () => {
+    const script = generateBashCompletions();
+    const commands = ['embed', 'rerank', 'store', 'search', 'index', 'models', 'ping', 'config', 'demo', 'explain', 'similarity', 'ingest', 'completions', 'help'];
+    for (const cmd of commands) {
+      assert.ok(script.includes(cmd), `should include command: ${cmd}`);
+    }
+  });
+
+  it('includes model completions', () => {
+    const script = generateBashCompletions();
+    assert.ok(script.includes('voyage-4-large'), 'should include voyage-4-large model');
+    assert.ok(script.includes('rerank-2.5'), 'should include rerank-2.5 model');
+  });
+
+  it('includes flag completions for embed', () => {
+    const script = generateBashCompletions();
+    assert.ok(script.includes('--model'), 'should include --model flag');
+    assert.ok(script.includes('--dimensions'), 'should include --dimensions flag');
+    assert.ok(script.includes('--input-type'), 'should include --input-type flag');
+  });
+
+  it('includes index subcommands', () => {
+    const script = generateBashCompletions();
+    assert.ok(script.includes('create list delete'), 'should include index subcommands');
+  });
+
+  it('includes config subcommands', () => {
+    const script = generateBashCompletions();
+    assert.ok(script.includes('set get delete path reset'), 'should include config subcommands');
+  });
+
+  it('includes input-type values', () => {
+    const script = generateBashCompletions();
+    assert.ok(script.includes('query document'), 'should include input-type values');
+  });
+});
+
+describe('generateZshCompletions', () => {
+  it('includes compdef header', () => {
+    const script = generateZshCompletions();
+    assert.ok(script.startsWith('#compdef vai'), 'should start with #compdef vai');
+  });
+
+  it('includes all commands with descriptions', () => {
+    const script = generateZshCompletions();
+    const commands = ['embed', 'rerank', 'store', 'search', 'index', 'models', 'ping', 'config', 'demo', 'explain', 'similarity', 'ingest', 'completions'];
+    for (const cmd of commands) {
+      assert.ok(script.includes(`'${cmd}:`), `should include command with description: ${cmd}`);
+    }
+  });
+
+  it('includes model names', () => {
+    const script = generateZshCompletions();
+    assert.ok(script.includes('voyage-4-large'), 'should include voyage-4-large model');
+    assert.ok(script.includes('voyage-code-3'), 'should include voyage-code-3 model');
+  });
+
+  it('includes explain topics', () => {
+    const script = generateZshCompletions();
+    assert.ok(script.includes('embeddings'), 'should include embeddings topic');
+    assert.ok(script.includes('cosine-similarity'), 'should include cosine-similarity topic');
+    assert.ok(script.includes('batch-processing'), 'should include batch-processing topic');
+  });
+
+  it('includes file completion for --file flags', () => {
+    const script = generateZshCompletions();
+    assert.ok(script.includes('_files'), 'should use _files completion');
+  });
+});

package/test/commands/embed.test.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const { describe, it, beforeEach, afterEach, mock } = require('node:test');
+const assert = require('node:assert/strict');
+const { Command } = require('commander');
+const { registerEmbed } = require('../../src/commands/embed');
+
+describe('embed command', () => {
+  it('registers correctly on a program', () => {
+    const program = new Command();
+    registerEmbed(program);
+    const embedCmd = program.commands.find(c => c.name() === 'embed');
+    assert.ok(embedCmd, 'embed command should be registered');
+  });
+
+  it('has --truncation flag', () => {
+    const program = new Command();
+    registerEmbed(program);
+    const embedCmd = program.commands.find(c => c.name() === 'embed');
+    const optionNames = embedCmd.options.map(o => o.long);
+    assert.ok(optionNames.includes('--truncation'), 'should have --truncation option');
+    assert.ok(optionNames.includes('--no-truncation'), 'should have --no-truncation option');
+  });
+
+  it('has --input-type flag', () => {
+    const program = new Command();
+    registerEmbed(program);
+    const embedCmd = program.commands.find(c => c.name() === 'embed');
+    const optionNames = embedCmd.options.map(o => o.long);
+    assert.ok(optionNames.includes('--input-type'), 'should have --input-type option');
+  });
+});

package/test/commands/ingest.test.js

@@ -243,6 +243,19 @@ describe('ingest', () => {
       assert.ok(optionNames.includes('--json'), 'should have --json option');
       assert.ok(optionNames.includes('--quiet'), 'should have --quiet option');
       assert.ok(optionNames.includes('--strict'), 'should have --strict option');
+      assert.ok(optionNames.includes('--input-type'), 'should have --input-type option');
+    });
+
+    it('--input-type defaults to document', () => {
+      delete require.cache[require.resolve('../../src/commands/ingest')];
+      const { registerIngest } = require('../../src/commands/ingest');
+      const { Command } = require('commander');
+      const program = new Command();
+      registerIngest(program);
+
+      const ingestCmd = program.commands.find(c => c.name() === 'ingest');
+      const inputTypeOpt = ingestCmd.options.find(o => o.long === '--input-type');
+      assert.equal(inputTypeOpt.defaultValue, 'document', '--input-type should default to document');
     });
   });
 });