voyageai-cli 1.12.1 → 1.15.0

package/test/lib/catalog.test.js

@@ -1,99 +0,0 @@
-'use strict';
-
-const { describe, it } = require('node:test');
-const assert = require('node:assert/strict');
-const {
-  MODEL_CATALOG,
-  DEFAULT_EMBED_MODEL,
-  DEFAULT_RERANK_MODEL,
-  DEFAULT_DIMENSIONS,
-} = require('../../src/lib/catalog');
-
-describe('catalog', () => {
-  it('MODEL_CATALOG is a non-empty array', () => {
-    assert.ok(Array.isArray(MODEL_CATALOG));
-    assert.ok(MODEL_CATALOG.length > 0);
-  });
-
-  it('contains expected models', () => {
-    const names = MODEL_CATALOG.map(m => m.name);
-    assert.ok(names.includes('voyage-4-large'));
-    assert.ok(names.includes('voyage-4'));
-    assert.ok(names.includes('voyage-4-lite'));
-    assert.ok(names.includes('rerank-2.5'));
-  });
-
-  it('DEFAULT_EMBED_MODEL is a valid embedding model', () => {
-    assert.equal(DEFAULT_EMBED_MODEL, 'voyage-4-large');
-    const model = MODEL_CATALOG.find(m => m.name === DEFAULT_EMBED_MODEL);
-    assert.ok(model);
-    assert.equal(model.type, 'embedding');
-  });
-
-  it('DEFAULT_RERANK_MODEL is a valid reranking model', () => {
-    assert.equal(DEFAULT_RERANK_MODEL, 'rerank-2.5');
-    const model = MODEL_CATALOG.find(m => m.name === DEFAULT_RERANK_MODEL);
-    assert.ok(model);
-    assert.equal(model.type, 'reranking');
-  });
-
-  it('DEFAULT_DIMENSIONS is 1024', () => {
-    assert.equal(DEFAULT_DIMENSIONS, 1024);
-  });
-
-  it('all models have required fields', () => {
-    const requiredFields = ['name', 'type', 'context', 'dimensions', 'price', 'bestFor'];
-    for (const model of MODEL_CATALOG) {
-      for (const field of requiredFields) {
-        assert.ok(
-          model[field] !== undefined && model[field] !== null && model[field] !== '',
-          `Model "${model.name}" is missing field "${field}"`
-        );
-      }
-    }
-  });
-
-  it('has both embedding and reranking types', () => {
-    const types = new Set(MODEL_CATALOG.map(m => m.type));
-    assert.ok(types.has('embedding'), 'Should have embedding models');
-    assert.ok(types.has('reranking'), 'Should have reranking models');
-  });
-
-  it('embedding models outnumber reranking models', () => {
-    const embedCount = MODEL_CATALOG.filter(m => m.type === 'embedding').length;
-    const rerankCount = MODEL_CATALOG.filter(m => m.type === 'reranking').length;
-    assert.ok(embedCount > rerankCount);
-  });
-
-  it('contains voyage-4-nano as current model', () => {
-    const nano = MODEL_CATALOG.find(m => m.name === 'voyage-4-nano');
-    assert.ok(nano, 'Should have voyage-4-nano');
-    assert.equal(nano.type, 'embedding');
-    assert.ok(!nano.legacy, 'voyage-4-nano should not be legacy');
-  });
-
-  it('contains legacy models with legacy flag', () => {
-    const legacyModels = MODEL_CATALOG.filter(m => m.legacy);
-    assert.ok(legacyModels.length > 0, 'Should have legacy models');
-
-    const legacyNames = legacyModels.map(m => m.name);
-    assert.ok(legacyNames.includes('voyage-3-large'), 'Should have voyage-3-large');
-    assert.ok(legacyNames.includes('voyage-3.5'), 'Should have voyage-3.5');
-    assert.ok(legacyNames.includes('voyage-3.5-lite'), 'Should have voyage-3.5-lite');
-    assert.ok(legacyNames.includes('voyage-code-2'), 'Should have voyage-code-2');
-    assert.ok(legacyNames.includes('voyage-multimodal-3'), 'Should have voyage-multimodal-3');
-    assert.ok(legacyNames.includes('rerank-2'), 'Should have rerank-2');
-    assert.ok(legacyNames.includes('rerank-2-lite'), 'Should have rerank-2-lite');
-  });
-
-  it('legacy models have required fields', () => {
-    const legacyModels = MODEL_CATALOG.filter(m => m.legacy);
-    for (const model of legacyModels) {
-      assert.ok(model.name, `Legacy model missing name`);
-      assert.ok(model.type, `Legacy model ${model.name} missing type`);
-      assert.ok(model.context, `Legacy model ${model.name} missing context`);
-      assert.ok(model.price, `Legacy model ${model.name} missing price`);
-      assert.ok(model.bestFor, `Legacy model ${model.name} missing bestFor`);
-    }
-  });
-});

package/test/lib/config.test.js

@@ -1,124 +0,0 @@
-'use strict';
-
-const { describe, it, beforeEach, afterEach } = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-const {
-  loadConfig,
-  saveConfig,
-  getConfigValue,
-  setConfigValue,
-  deleteConfigValue,
-  maskSecret,
-} = require('../../src/lib/config');
-
-describe('config lib', () => {
-  let tmpDir;
-  let tmpConfigPath;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'vai-test-'));
-    tmpConfigPath = path.join(tmpDir, 'config.json');
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  describe('loadConfig', () => {
-    it('returns {} when config file does not exist', () => {
-      const config = loadConfig(tmpConfigPath);
-      assert.deepEqual(config, {});
-    });
-
-    it('returns parsed config when file exists', () => {
-      fs.writeFileSync(tmpConfigPath, JSON.stringify({ apiKey: 'test' }));
-      const config = loadConfig(tmpConfigPath);
-      assert.deepEqual(config, { apiKey: 'test' });
-    });
-  });
-
-  describe('saveConfig', () => {
-    it('creates directory and file', () => {
-      const nestedPath = path.join(tmpDir, 'nested', 'config.json');
-      saveConfig({ foo: 'bar' }, nestedPath);
-      assert.ok(fs.existsSync(nestedPath));
-      const data = JSON.parse(fs.readFileSync(nestedPath, 'utf-8'));
-      assert.deepEqual(data, { foo: 'bar' });
-    });
-
-    it('sets file permissions to 600', () => {
-      saveConfig({ secret: 'value' }, tmpConfigPath);
-      const stats = fs.statSync(tmpConfigPath);
-      const mode = (stats.mode & 0o777).toString(8);
-      assert.equal(mode, '600');
-    });
-  });
-
-  describe('setConfigValue / getConfigValue', () => {
-    it('round-trips a value', () => {
-      setConfigValue('apiKey', 'my-secret-key', tmpConfigPath);
-      const value = getConfigValue('apiKey', tmpConfigPath);
-      assert.equal(value, 'my-secret-key');
-    });
-
-    it('returns undefined for missing key', () => {
-      const value = getConfigValue('nonExistent', tmpConfigPath);
-      assert.equal(value, undefined);
-    });
-
-    it('handles multiple values', () => {
-      setConfigValue('apiKey', 'key1', tmpConfigPath);
-      setConfigValue('mongodbUri', 'mongodb://localhost', tmpConfigPath);
-      assert.equal(getConfigValue('apiKey', tmpConfigPath), 'key1');
-      assert.equal(getConfigValue('mongodbUri', tmpConfigPath), 'mongodb://localhost');
-    });
-
-    it('overwrites existing value', () => {
-      setConfigValue('apiKey', 'old', tmpConfigPath);
-      setConfigValue('apiKey', 'new', tmpConfigPath);
-      assert.equal(getConfigValue('apiKey', tmpConfigPath), 'new');
-    });
-  });
-
-  describe('deleteConfigValue', () => {
-    it('removes a key', () => {
-      setConfigValue('apiKey', 'val', tmpConfigPath);
-      deleteConfigValue('apiKey', tmpConfigPath);
-      assert.equal(getConfigValue('apiKey', tmpConfigPath), undefined);
-    });
-
-    it('does not affect other keys', () => {
-      setConfigValue('apiKey', 'key', tmpConfigPath);
-      setConfigValue('mongodbUri', 'uri', tmpConfigPath);
-      deleteConfigValue('apiKey', tmpConfigPath);
-      assert.equal(getConfigValue('mongodbUri', tmpConfigPath), 'uri');
-    });
-  });
-
-  describe('maskSecret', () => {
-    it('masks long strings: first 4 + ... + last 4', () => {
-      assert.equal(maskSecret('al-EdFh1FwUCPTZw7ofd93ulmRNxEmt-JOCRmmWc96wWJ8'), 'al-E...wWJ8');
-    });
-
-    it('masks strings of exactly 10 chars', () => {
-      assert.equal(maskSecret('1234567890'), '1234...7890');
-    });
-
-    it('returns **** for strings shorter than 10 chars', () => {
-      assert.equal(maskSecret('short'), '****');
-      assert.equal(maskSecret('123456789'), '****');
-    });
-
-    it('returns **** for empty string', () => {
-      assert.equal(maskSecret(''), '****');
-    });
-
-    it('converts non-string values to string', () => {
-      assert.equal(maskSecret(12345), '12345');
-    });
-  });
-});

package/test/lib/explanations.test.js

@@ -1,141 +0,0 @@
-'use strict';
-
-const { describe, it } = require('node:test');
-const assert = require('node:assert/strict');
-const { concepts, aliases, resolveConcept, listConcepts, getConcept } = require('../../src/lib/explanations');
-
-describe('explanations', () => {
-  const expectedConcepts = [
-    'embeddings',
-    'reranking',
-    'vector-search',
-    'rag',
-    'cosine-similarity',
-    'two-stage-retrieval',
-    'input-type',
-    'models',
-    'api-keys',
-    'api-access',
-    'batch-processing',
-    'quantization',
-    'benchmarking',
-  ];
-
-  it('has all expected concepts', () => {
-    for (const key of expectedConcepts) {
-      assert.ok(concepts[key], `Missing concept: ${key}`);
-    }
-  });
-
-  it('listConcepts returns all concept keys', () => {
-    const keys = listConcepts();
-    assert.equal(keys.length, expectedConcepts.length);
-    for (const key of expectedConcepts) {
-      assert.ok(keys.includes(key), `listConcepts should include ${key}`);
-    }
-  });
-
-  it('all concepts have required fields: title, summary, content, links, tryIt', () => {
-    for (const key of expectedConcepts) {
-      const concept = concepts[key];
-      assert.ok(concept.title, `${key} should have title`);
-      assert.ok(typeof concept.title === 'string', `${key}.title should be a string`);
-      assert.ok(concept.summary, `${key} should have summary`);
-      assert.ok(typeof concept.summary === 'string', `${key}.summary should be a string`);
-      assert.ok(concept.content, `${key} should have content`);
-      assert.ok(typeof concept.content === 'string', `${key}.content should be a string`);
-      assert.ok(Array.isArray(concept.links), `${key}.links should be an array`);
-      assert.ok(concept.links.length > 0, `${key}.links should not be empty`);
-      assert.ok(Array.isArray(concept.tryIt), `${key}.tryIt should be an array`);
-      assert.ok(concept.tryIt.length > 0, `${key}.tryIt should not be empty`);
-    }
-  });
-
-  it('all concepts have substantial content (at least 200 chars)', () => {
-    const stripAnsi = (str) => str.replace(/\x1b\[[0-9;]*m/g, '');
-    for (const key of expectedConcepts) {
-      const plainContent = stripAnsi(concepts[key].content);
-      assert.ok(
-        plainContent.length >= 200,
-        `${key} content should be substantial (got ${plainContent.length} chars)`
-      );
-    }
-  });
-
-  it('getConcept returns concept for valid key', () => {
-    const concept = getConcept('embeddings');
-    assert.ok(concept);
-    assert.equal(concept.title, 'Embeddings');
-  });
-
-  it('getConcept returns null for invalid key', () => {
-    const concept = getConcept('nonexistent');
-    assert.equal(concept, null);
-  });
-
-  describe('alias resolution', () => {
-    const expectedAliases = {
-      embed: 'embeddings',
-      embedding: 'embeddings',
-      rerank: 'reranking',
-      vectors: 'vector-search',
-      search: 'vector-search',
-      cosine: 'cosine-similarity',
-      similarity: 'cosine-similarity',
-      'two-stage': 'two-stage-retrieval',
-      keys: 'api-keys',
-      access: 'api-access',
-      auth: 'api-access',
-      'atlas-vs-voyage': 'api-access',
-      endpoint: 'api-access',
-      batch: 'batch-processing',
-      model: 'models',
-      batching: 'batch-processing',
-      quantize: 'quantization',
-      int8: 'quantization',
-      binary: 'quantization',
-      matryoshka: 'quantization',
-      dtype: 'quantization',
-    };
-
-    it('alias map covers expected aliases', () => {
-      for (const [alias, expected] of Object.entries(expectedAliases)) {
-        assert.ok(aliases[alias], `Alias map should include "${alias}"`);
-        assert.equal(aliases[alias], expected, `Alias "${alias}" should resolve to "${expected}"`);
-      }
-    });
-
-    it('resolveConcept resolves direct keys', () => {
-      for (const key of expectedConcepts) {
-        assert.equal(resolveConcept(key), key, `Direct key "${key}" should resolve to itself`);
-      }
-    });
-
-    it('resolveConcept resolves aliases', () => {
-      for (const [alias, expected] of Object.entries(expectedAliases)) {
-        assert.equal(
-          resolveConcept(alias),
-          expected,
-          `Alias "${alias}" should resolve to "${expected}"`
-        );
-      }
-    });
-
-    it('resolveConcept is case-insensitive', () => {
-      assert.equal(resolveConcept('EMBEDDINGS'), 'embeddings');
-      assert.equal(resolveConcept('Rerank'), 'reranking');
-      assert.equal(resolveConcept('RAG'), 'rag');
-    });
-
-    it('resolveConcept returns null for unknown input', () => {
-      assert.equal(resolveConcept('nonexistent'), null);
-      assert.equal(resolveConcept('foobar'), null);
-    });
-
-    it('resolveConcept returns null for empty/null input', () => {
-      assert.equal(resolveConcept(''), null);
-      assert.equal(resolveConcept(null), null);
-      assert.equal(resolveConcept(undefined), null);
-    });
-  });
-});

package/test/lib/format.test.js

@@ -1,75 +0,0 @@
-'use strict';
-
-const { describe, it } = require('node:test');
-const assert = require('node:assert/strict');
-const { formatTable } = require('../../src/lib/format');
-
-describe('formatTable', () => {
-  it('formats a simple table', () => {
-    const headers = ['Name', 'Age'];
-    const rows = [
-      ['Alice', '30'],
-      ['Bob', '25'],
-    ];
-    const result = formatTable(headers, rows);
-    assert.ok(result.includes('Alice'));
-    assert.ok(result.includes('Bob'));
-    assert.ok(result.includes('Name'));
-    assert.ok(result.includes('Age'));
-  });
-
-  it('handles empty rows', () => {
-    const headers = ['Col1', 'Col2'];
-    const rows = [];
-    const result = formatTable(headers, rows);
-    // Should still have the header and separator
-    const lines = result.split('\n');
-    assert.equal(lines.length, 2); // header + separator, no data lines
-    assert.ok(lines[0].includes('Col1'));
-    assert.ok(lines[0].includes('Col2'));
-  });
-
-  it('handles varying column widths', () => {
-    const headers = ['X', 'Long Header'];
-    const rows = [
-      ['Short', 'Y'],
-      ['A very long cell value', 'Z'],
-    ];
-    const result = formatTable(headers, rows);
-    // The widest cell should determine column width
-    assert.ok(result.includes('A very long cell value'));
-    // All rows should have consistent separators
-    const lines = result.split('\n');
-    assert.equal(lines.length, 4); // header + separator + 2 data rows
-  });
-
-  it('uses correct separator character', () => {
-    const headers = ['A', 'B'];
-    const rows = [['1', '2']];
-    const result = formatTable(headers, rows);
-    const lines = result.split('\n');
-    // Separator line should contain ─ and ┼
-    assert.ok(lines[1].includes('─'));
-    assert.ok(lines[1].includes('┼'));
-  });
-
-  it('uses │ as column separator in data lines', () => {
-    const headers = ['A', 'B'];
-    const rows = [['1', '2']];
-    const result = formatTable(headers, rows);
-    const lines = result.split('\n');
-    // Header and data lines should use │
-    assert.ok(lines[0].includes('│'));
-    assert.ok(lines[2].includes('│'));
-  });
-
-  it('pads cells correctly', () => {
-    const headers = ['Name', 'Value'];
-    const rows = [['A', 'B']];
-    const result = formatTable(headers, rows);
-    const lines = result.split('\n');
-    // Each cell should be padded to column width
-    // "Name" is 4 chars, "A" should be padded to 4
-    assert.ok(lines[2].includes(' A    ') || lines[2].includes(' A '));
-  });
-});

package/test/lib/input.test.js

@@ -1,48 +0,0 @@
-'use strict';
-
-const { describe, it, after } = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { resolveTextInput } = require('../../src/lib/input');
-
-describe('resolveTextInput', () => {
-  const tmpFiles = [];
-
-  function createTempFile(content) {
-    const tmpPath = path.join(os.tmpdir(), `vai-test-${Date.now()}-${Math.random().toString(36).slice(2)}.txt`);
-    fs.writeFileSync(tmpPath, content, 'utf-8');
-    tmpFiles.push(tmpPath);
-    return tmpPath;
-  }
-
-  after(() => {
-    for (const f of tmpFiles) {
-      try { fs.unlinkSync(f); } catch { /* ignore */ }
-    }
-  });
-
-  it('returns direct text argument as array', async () => {
-    const result = await resolveTextInput('hello world', undefined);
-    assert.deepEqual(result, ['hello world']);
-  });
-
-  it('reads from file path', async () => {
-    const tmpPath = createTempFile('file content here');
-    const result = await resolveTextInput(undefined, tmpPath);
-    assert.deepEqual(result, ['file content here']);
-  });
-
-  it('trims file content', async () => {
-    const tmpPath = createTempFile('  trimmed  \n');
-    const result = await resolveTextInput(undefined, tmpPath);
-    assert.deepEqual(result, ['trimmed']);
-  });
-
-  it('prefers file over text argument', async () => {
-    const tmpPath = createTempFile('from file');
-    const result = await resolveTextInput('from arg', tmpPath);
-    assert.deepEqual(result, ['from file']);
-  });
-});

package/test/lib/math.test.js

@@ -1,43 +0,0 @@
-'use strict';
-
-const { describe, it } = require('node:test');
-const assert = require('node:assert/strict');
-const { cosineSimilarity } = require('../../src/lib/math');
-
-describe('cosineSimilarity', () => {
-  it('returns 1.0 for identical vectors', () => {
-    const v = [1, 2, 3, 4, 5];
-    const result = cosineSimilarity(v, v);
-    assert.ok(Math.abs(result - 1.0) < 1e-10, `Expected ~1.0, got ${result}`);
-  });
-
-  it('returns 0.0 for orthogonal vectors', () => {
-    const a = [1, 0, 0];
-    const b = [0, 1, 0];
-    const result = cosineSimilarity(a, b);
-    assert.ok(Math.abs(result) < 1e-10, `Expected ~0.0, got ${result}`);
-  });
-
-  it('returns -1.0 for opposite vectors', () => {
-    const a = [1, 2, 3];
-    const b = [-1, -2, -3];
-    const result = cosineSimilarity(a, b);
-    assert.ok(Math.abs(result - (-1.0)) < 1e-10, `Expected ~-1.0, got ${result}`);
-  });
-
-  it('computes correct value for known vectors', () => {
-    // cos([1,0], [1,1]) = 1 / (1 * sqrt(2)) ≈ 0.7071
-    const a = [1, 0];
-    const b = [1, 1];
-    const result = cosineSimilarity(a, b);
-    const expected = 1 / Math.sqrt(2);
-    assert.ok(Math.abs(result - expected) < 1e-10, `Expected ~${expected}, got ${result}`);
-  });
-
-  it('returns ~1.0 for vectors of different magnitudes but same direction', () => {
-    const a = [1, 2, 3];
-    const b = [10, 20, 30];
-    const result = cosineSimilarity(a, b);
-    assert.ok(Math.abs(result - 1.0) < 1e-10, `Expected ~1.0, got ${result}`);
-  });
-});

package/test/lib/ui.test.js

@@ -1,79 +0,0 @@
-'use strict';
-
-const { describe, it } = require('node:test');
-const assert = require('node:assert/strict');
-const ui = require('../../src/lib/ui');
-
-describe('ui helpers', () => {
-  it('ui.success() contains ✓', () => {
-    const result = ui.success('done');
-    assert.ok(result.includes('✓'), `Expected "✓" in: ${result}`);
-    assert.ok(result.includes('done'), `Expected "done" in: ${result}`);
-  });
-
-  it('ui.error() contains ✗', () => {
-    const result = ui.error('fail');
-    assert.ok(result.includes('✗'), `Expected "✗" in: ${result}`);
-    assert.ok(result.includes('fail'), `Expected "fail" in: ${result}`);
-  });
-
-  it('ui.warn() contains ⚠', () => {
-    const result = ui.warn('careful');
-    assert.ok(result.includes('⚠'), `Expected "⚠" in: ${result}`);
-  });
-
-  it('ui.info() contains ℹ', () => {
-    const result = ui.info('note');
-    assert.ok(result.includes('ℹ'), `Expected "ℹ" in: ${result}`);
-  });
-
-  it('ui.score() returns a string for various values', () => {
-    const high = ui.score(0.85);
-    assert.equal(typeof high, 'string');
-    assert.ok(high.includes('0.850000'), `Expected "0.850000" in: ${high}`);
-
-    const mid = ui.score(0.55);
-    assert.equal(typeof mid, 'string');
-    assert.ok(mid.includes('0.550000'), `Expected "0.550000" in: ${mid}`);
-
-    const low = ui.score(0.1);
-    assert.equal(typeof low, 'string');
-    assert.ok(low.includes('0.100000'), `Expected "0.100000" in: ${low}`);
-  });
-
-  it('ui.label() formats key: value with indentation', () => {
-    const result = ui.label('Model', 'voyage-4');
-    assert.ok(result.includes('Model'), `Expected "Model" in: ${result}`);
-    assert.ok(result.includes(':'), `Expected ":" in: ${result}`);
-    assert.ok(result.includes('voyage-4'), `Expected "voyage-4" in: ${result}`);
-    // Should start with spaces (indentation)
-    assert.ok(result.startsWith('  '), `Expected leading spaces in: ${result}`);
-  });
-
-  it('ui.status() colors READY green, BUILDING yellow, FAILED red', () => {
-    const ready = ui.status('READY');
-    assert.equal(typeof ready, 'string');
-    assert.ok(ready.includes('READY'), `Expected "READY" in: ${ready}`);
-
-    const building = ui.status('BUILDING');
-    assert.ok(building.includes('BUILDING'), `Expected "BUILDING" in: ${building}`);
-
-    const failed = ui.status('FAILED');
-    assert.ok(failed.includes('FAILED'), `Expected "FAILED" in: ${failed}`);
-  });
-
-  it('ui.spinner() returns an object with start and stop methods', () => {
-    const spin = ui.spinner('loading...');
-    assert.equal(typeof spin.start, 'function', 'spinner should have start()');
-    assert.equal(typeof spin.stop, 'function', 'spinner should have stop()');
-  });
-
-  it('ui style functions exist and return strings', () => {
-    assert.equal(typeof ui.bold('x'), 'string');
-    assert.equal(typeof ui.dim('x'), 'string');
-    assert.equal(typeof ui.green('x'), 'string');
-    assert.equal(typeof ui.red('x'), 'string');
-    assert.equal(typeof ui.cyan('x'), 'string');
-    assert.equal(typeof ui.yellow('x'), 'string');
-  });
-});