voyageai-cli 1.4.0 → 1.6.0

package/test/commands/models.test.js

@@ -86,4 +86,47 @@ describe('models command', () => {
     assert.ok(parsed[0].name);
     assert.ok(parsed[0].type);
   });
+
+  it('hides legacy models by default', async () => {
+    const program = new Command();
+    program.exitOverride();
+    registerModels(program);
+
+    await program.parseAsync(['node', 'test', 'models', '--quiet']);
+
+    const combined = output.join('\n');
+    assert.ok(combined.includes('voyage-4-large'), 'Should include current models');
+    assert.ok(!combined.includes('voyage-3-large'), 'Should hide legacy voyage-3-large');
+    assert.ok(!combined.includes('rerank-2-lite'), 'Should hide legacy rerank-2-lite');
+    assert.ok(!combined.includes('voyage-code-2'), 'Should hide legacy voyage-code-2');
+  });
+
+  it('shows legacy models when --all is used', async () => {
+    const program = new Command();
+    program.exitOverride();
+    registerModels(program);
+
+    await program.parseAsync(['node', 'test', 'models', '--all', '--quiet']);
+
+    const combined = output.join('\n');
+    assert.ok(combined.includes('voyage-4-large'), 'Should include current models');
+    assert.ok(combined.includes('voyage-3-large'), 'Should include legacy voyage-3-large');
+    assert.ok(combined.includes('rerank-2'), 'Should include legacy rerank-2');
+    assert.ok(combined.includes('Legacy Models'), 'Should show legacy header');
+  });
+
+  it('--all with --json shows legacy models in JSON', async () => {
+    const program = new Command();
+    program.exitOverride();
+    registerModels(program);
+
+    await program.parseAsync(['node', 'test', 'models', '--all', '--json']);
+
+    const combined = output.join('\n');
+    const parsed = JSON.parse(combined);
+    assert.ok(Array.isArray(parsed));
+    const legacyNames = parsed.filter(m => m.legacy).map(m => m.name);
+    assert.ok(legacyNames.includes('voyage-3-large'), 'JSON should include legacy models');
+    assert.ok(legacyNames.includes('rerank-2'), 'JSON should include legacy rerankers');
+  });
 });

package/test/commands/ping.test.js

@@ -105,8 +105,17 @@ describe('ping command', () => {
     assert.ok(combined.includes('Authentication failed'), 'Should show auth error');
   });
 
-  it('exits when VOYAGE_API_KEY is not set', async () => {
+  it('exits when VOYAGE_API_KEY is not set and no config', async () => {
     delete process.env.VOYAGE_API_KEY;
+    // Mock config to return nothing so the key isn't found in ~/.vai/config.json
+    delete require.cache[require.resolve('../../src/lib/config')];
+    delete require.cache[require.resolve('../../src/lib/api')];
+    delete require.cache[require.resolve('../../src/commands/ping')];
+    const config = require('../../src/lib/config');
+    const origGetConfigValue = config.getConfigValue;
+    config.getConfigValue = () => undefined;
+
+    const { registerPing: registerPingFresh } = require('../../src/commands/ping');
 
     let exitCode = null;
     process.exit = (code) => {
@@ -116,16 +125,20 @@ describe('ping command', () => {
 
     const program = new Command();
     program.exitOverride();
-    registerPing(program);
-
-    await assert.rejects(
-      () => program.parseAsync(['node', 'test', 'ping']),
-      /process\.exit called/
-    );
-
-    assert.equal(exitCode, 1);
-    const combined = errorOutput.join('\n');
-    assert.ok(combined.includes('VOYAGE_API_KEY'), 'Should mention missing key');
+    registerPingFresh(program);
+
+    try {
+      await assert.rejects(
+        () => program.parseAsync(['node', 'test', 'ping']),
+        /process\.exit called/
+      );
+
+      assert.equal(exitCode, 1);
+      const combined = errorOutput.join('\n');
+      assert.ok(combined.includes('VOYAGE_API_KEY'), 'Should mention missing key');
+    } finally {
+      config.getConfigValue = origGetConfigValue;
+    }
   });
 
   it('outputs JSON when --json flag is used', async () => {

package/test/commands/rerank.test.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+const { Command } = require('commander');
+const { registerRerank } = require('../../src/commands/rerank');
+
+describe('rerank command', () => {
+  it('registers correctly on a program', () => {
+    const program = new Command();
+    registerRerank(program);
+    const rerankCmd = program.commands.find(c => c.name() === 'rerank');
+    assert.ok(rerankCmd, 'rerank command should be registered');
+  });
+
+  it('has --truncation flag', () => {
+    const program = new Command();
+    registerRerank(program);
+    const rerankCmd = program.commands.find(c => c.name() === 'rerank');
+    const optionNames = rerankCmd.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 --return-documents flag', () => {
+    const program = new Command();
+    registerRerank(program);
+    const rerankCmd = program.commands.find(c => c.name() === 'rerank');
+    const optionNames = rerankCmd.options.map(o => o.long);
+    assert.ok(optionNames.includes('--return-documents'), 'should have --return-documents option');
+  });
+});

package/test/commands/store.test.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+const { Command } = require('commander');
+const { registerStore } = require('../../src/commands/store');
+
+describe('store command', () => {
+  it('registers correctly on a program', () => {
+    const program = new Command();
+    registerStore(program);
+    const storeCmd = program.commands.find(c => c.name() === 'store');
+    assert.ok(storeCmd, 'store command should be registered');
+  });
+
+  it('has --input-type flag defaulting to document', () => {
+    const program = new Command();
+    registerStore(program);
+    const storeCmd = program.commands.find(c => c.name() === 'store');
+    const optionNames = storeCmd.options.map(o => o.long);
+    assert.ok(optionNames.includes('--input-type'), 'should have --input-type option');
+    // Check the default value
+    const inputTypeOpt = storeCmd.options.find(o => o.long === '--input-type');
+    assert.equal(inputTypeOpt.defaultValue, 'document', '--input-type should default to document');
+  });
+});

package/test/lib/api.test.js

@@ -25,8 +25,13 @@ describe('api', () => {
   describe('requireApiKey', () => {
     it('throws/exits when VOYAGE_API_KEY is not set', () => {
       delete process.env.VOYAGE_API_KEY;
-      // Re-require to get fresh module
+      // Re-require to get fresh modules (clear config cache too)
       delete require.cache[require.resolve('../../src/lib/api')];
+      delete require.cache[require.resolve('../../src/lib/config')];
+      const config = require('../../src/lib/config');
+      const originalGetConfigValue = config.getConfigValue;
+      config.getConfigValue = () => undefined;
+
       const { requireApiKey } = require('../../src/lib/api');
 
       let exitCode = null;
@@ -35,8 +40,12 @@ describe('api', () => {
         throw new Error('process.exit called');
       };
 
-      assert.throws(() => requireApiKey(), /process\.exit called/);
-      assert.equal(exitCode, 1);
+      try {
+        assert.throws(() => requireApiKey(), /process\.exit called/);
+        assert.equal(exitCode, 1);
+      } finally {
+        config.getConfigValue = originalGetConfigValue;
+      }
     });
 
     it('returns key when VOYAGE_API_KEY is set', () => {

package/test/lib/catalog.test.js

@@ -64,4 +64,36 @@ describe('catalog', () => {
     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`);
+    }
+  });
 });