voyageai-cli 1.1.0 → 1.3.0

package/src/lib/config.js

@@ -0,0 +1,107 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CONFIG_DIR = path.join(os.homedir(), '.vai');
+const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
+
+// Key mapping: CLI key names → internal config keys
+const KEY_MAP = {
+  'api-key': 'apiKey',
+  'mongodb-uri': 'mongodbUri',
+  'default-model': 'defaultModel',
+  'default-dimensions': 'defaultDimensions',
+};
+
+// Keys whose values should be masked in output
+const SECRET_KEYS = new Set(['apiKey', 'mongodbUri']);
+
+/**
+ * Load config from disk. Returns {} if file doesn't exist.
+ * @param {string} [configPath] - Override config path (for testing)
+ * @returns {object}
+ */
+function loadConfig(configPath) {
+  const p = configPath || CONFIG_PATH;
+  try {
+    const raw = fs.readFileSync(p, 'utf-8');
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err.code === 'ENOENT') return {};
+    throw err;
+  }
+}
+
+/**
+ * Save config to disk. Creates directory if needed, chmod 600 on the file.
+ * @param {object} config
+ * @param {string} [configPath] - Override config path (for testing)
+ */
+function saveConfig(config, configPath) {
+  const p = configPath || CONFIG_PATH;
+  const dir = path.dirname(p);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(p, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+  fs.chmodSync(p, 0o600);
+}
+
+/**
+ * Get a single config value.
+ * @param {string} key - Internal config key (e.g. 'apiKey')
+ * @param {string} [configPath] - Override config path (for testing)
+ * @returns {*}
+ */
+function getConfigValue(key, configPath) {
+  const config = loadConfig(configPath);
+  return config[key];
+}
+
+/**
+ * Set a single config value.
+ * @param {string} key - Internal config key
+ * @param {*} value
+ * @param {string} [configPath] - Override config path (for testing)
+ */
+function setConfigValue(key, value, configPath) {
+  const config = loadConfig(configPath);
+  config[key] = value;
+  saveConfig(config, configPath);
+}
+
+/**
+ * Delete a single config value.
+ * @param {string} key - Internal config key
+ * @param {string} [configPath] - Override config path (for testing)
+ */
+function deleteConfigValue(key, configPath) {
+  const config = loadConfig(configPath);
+  delete config[key];
+  saveConfig(config, configPath);
+}
+
+/**
+ * Mask a secret string: show first 4 + '...' + last 4 chars.
+ * If < 10 chars, return '****'.
+ * @param {string} value
+ * @returns {string}
+ */
+function maskSecret(value) {
+  if (typeof value !== 'string') return String(value);
+  if (value.length < 10) return '****';
+  return value.slice(0, 4) + '...' + value.slice(-4);
+}
+
+module.exports = {
+  CONFIG_DIR,
+  CONFIG_PATH,
+  KEY_MAP,
+  SECRET_KEYS,
+  loadConfig,
+  saveConfig,
+  getConfigValue,
+  setConfigValue,
+  deleteConfigValue,
+  maskSecret,
+};

package/src/lib/mongo.js

@@ -2,15 +2,17 @@
 
 /**
  * Get MongoDB URI or exit with a helpful error.
+ * Checks: env var → config file.
  * @returns {string}
  */
 function requireMongoUri() {
-  const uri = process.env.MONGODB_URI;
+  const { getConfigValue } = require('./config');
+  const uri = process.env.MONGODB_URI || getConfigValue('mongodbUri');
   if (!uri) {
-    console.error('Error: MONGODB_URI environment variable is not set.');
+    console.error('Error: MONGODB_URI is not set.');
     console.error('');
-    console.error('Set your Atlas connection string:');
-    console.error('  export MONGODB_URI="mongodb+srv://user:pass@cluster.mongodb.net/"');
+    console.error('Option 1: export MONGODB_URI="mongodb+srv://user:pass@cluster.mongodb.net/"');
+    console.error('Option 2: vai config set mongodb-uri "mongodb+srv://user:pass@cluster.mongodb.net/"');
     process.exit(1);
   }
   return uri;

package/src/lib/ui.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const pc = require('picocolors');
+const oraModule = require('ora');
+const ora = oraModule.default || oraModule;
+
+// Semantic color helpers
+const ui = {
+  // Status indicators
+  success: (msg) => `${pc.green('✓')} ${msg}`,
+  error: (msg) => `${pc.red('✗')} ${msg}`,
+  warn: (msg) => `${pc.yellow('⚠')} ${msg}`,
+  info: (msg) => `${pc.cyan('ℹ')} ${msg}`,
+
+  // Text styling
+  bold: pc.bold,
+  dim: pc.dim,
+  green: pc.green,
+  red: pc.red,
+  cyan: pc.cyan,
+  yellow: pc.yellow,
+
+  // Labels
+  label: (key, value) => `  ${pc.dim(key + ':')}  ${value}`,
+
+  // Score formatting (0-1 scale: green > 0.7, yellow > 0.4, red otherwise)
+  score: (val) => {
+    const formatted = val.toFixed(6);
+    if (val >= 0.7) return pc.green(formatted);
+    if (val >= 0.4) return pc.yellow(formatted);
+    return pc.red(formatted);
+  },
+
+  // Index status coloring
+  status: (s) => {
+    const upper = (s || '').toUpperCase();
+    if (upper === 'READY') return pc.green(s);
+    if (upper === 'BUILDING') return pc.yellow(s);
+    if (upper === 'FAILED') return pc.red(s);
+    return s;
+  },
+
+  // Spinner
+  spinner: (text) => ora({ text, color: 'cyan' }),
+};
+
+module.exports = ui;

package/test/commands/config.test.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const { describe, it, beforeEach, afterEach } = require('node:test');
+const assert = require('node:assert/strict');
+const { Command } = require('commander');
+const { registerConfig } = require('../../src/commands/config');
+
+describe('config command', () => {
+  it('registers config command with subcommands', () => {
+    const program = new Command();
+    program.exitOverride();
+    registerConfig(program);
+
+    const configCmd = program.commands.find(c => c.name() === 'config');
+    assert.ok(configCmd, 'config command should be registered');
+
+    const subNames = configCmd.commands.map(c => c.name());
+    assert.ok(subNames.includes('set'), 'should have set subcommand');
+    assert.ok(subNames.includes('get'), 'should have get subcommand');
+    assert.ok(subNames.includes('delete'), 'should have delete subcommand');
+    assert.ok(subNames.includes('path'), 'should have path subcommand');
+    assert.ok(subNames.includes('reset'), 'should have reset subcommand');
+  });
+
+  it('config set/get/delete round-trip via lib functions', () => {
+    // This test exercises the underlying lib (already tested in config.test.js)
+    // but validates the key mapping used by the command
+    const { KEY_MAP } = require('../../src/lib/config');
+
+    assert.equal(KEY_MAP['api-key'], 'apiKey');
+    assert.equal(KEY_MAP['mongodb-uri'], 'mongodbUri');
+    assert.equal(KEY_MAP['default-model'], 'defaultModel');
+    assert.equal(KEY_MAP['default-dimensions'], 'defaultDimensions');
+  });
+});

package/test/commands/demo.test.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+const { Command } = require('commander');
+const { registerDemo } = require('../../src/commands/demo');
+
+describe('demo command', () => {
+  it('registers correctly on a program', () => {
+    const program = new Command();
+    registerDemo(program);
+    const demoCmd = program.commands.find(c => c.name() === 'demo');
+    assert.ok(demoCmd, 'demo command should be registered');
+  });
+
+  it('has --no-pause option', () => {
+    const program = new Command();
+    registerDemo(program);
+    const demoCmd = program.commands.find(c => c.name() === 'demo');
+    const opts = demoCmd.options.map(o => o.long);
+    assert.ok(opts.includes('--no-pause'), 'Should have --no-pause option');
+  });
+
+  it('has --skip-pipeline option', () => {
+    const program = new Command();
+    registerDemo(program);
+    const demoCmd = program.commands.find(c => c.name() === 'demo');
+    const opts = demoCmd.options.map(o => o.long);
+    assert.ok(opts.includes('--skip-pipeline'), 'Should have --skip-pipeline option');
+  });
+
+  it('has --keep option', () => {
+    const program = new Command();
+    registerDemo(program);
+    const demoCmd = program.commands.find(c => c.name() === 'demo');
+    const opts = demoCmd.options.map(o => o.long);
+    assert.ok(opts.includes('--keep'), 'Should have --keep option');
+  });
+
+  it('has correct description', () => {
+    const program = new Command();
+    registerDemo(program);
+    const demoCmd = program.commands.find(c => c.name() === 'demo');
+    assert.ok(demoCmd.description().includes('walkthrough'), 'Should mention walkthrough');
+  });
+});

package/test/commands/models.test.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const { describe, it, beforeEach, afterEach, mock } = require('node:test');
+const assert = require('node:assert/strict');
+const { Command } = require('commander');
+const { registerModels } = require('../../src/commands/models');
+
+describe('models command', () => {
+  let originalLog;
+  let output;
+
+  beforeEach(() => {
+    originalLog = console.log;
+    output = [];
+    console.log = (...args) => output.push(args.join(' '));
+  });
+
+  afterEach(() => {
+    console.log = originalLog;
+    mock.restoreAll();
+  });
+
+  it('registers correctly on a program', () => {
+    const program = new Command();
+    registerModels(program);
+    const modelsCmd = program.commands.find(c => c.name() === 'models');
+    assert.ok(modelsCmd, 'models command should be registered');
+    assert.ok(modelsCmd.description().includes('model'), 'should have a description about models');
+  });
+
+  it('lists all 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 voyage-4-large');
+    assert.ok(combined.includes('rerank-2.5'), 'Should include rerank-2.5');
+  });
+
+  it('filters by embedding type', async () => {
+    const program = new Command();
+    program.exitOverride();
+    registerModels(program);
+
+    await program.parseAsync(['node', 'test', 'models', '--type', 'embedding', '--quiet']);
+
+    const combined = output.join('\n');
+    assert.ok(combined.includes('voyage-4-large'), 'Should include embedding models');
+    assert.ok(!combined.includes('rerank-2.5\n'), 'Should not include reranking in data rows');
+    // More precise: check that rerank-2.5 doesn't appear as a data row start
+    const lines = combined.split('\n');
+    const dataLines = lines.filter(l => !l.includes('─') && l.trim().length > 0);
+    const hasRerankRow = dataLines.some(l => l.trim().startsWith('rerank-2.5'));
+    assert.ok(!hasRerankRow, 'Should not have reranking model rows');
+  });
+
+  it('filters by reranking type', async () => {
+    const program = new Command();
+    program.exitOverride();
+    registerModels(program);
+
+    await program.parseAsync(['node', 'test', 'models', '--type', 'reranking', '--quiet']);
+
+    const combined = output.join('\n');
+    assert.ok(combined.includes('rerank'), 'Should include reranking models');
+    const lines = combined.split('\n');
+    const dataLines = lines.filter(l => !l.includes('─') && !l.includes('Model') && l.trim().length > 0);
+    const hasEmbedRow = dataLines.some(l => l.includes('voyage-4-large'));
+    assert.ok(!hasEmbedRow, 'Should not have embedding model rows');
+  });
+
+  it('outputs JSON when --json flag is used', async () => {
+    const program = new Command();
+    program.exitOverride();
+    registerModels(program);
+
+    await program.parseAsync(['node', 'test', 'models', '--json']);
+
+    const combined = output.join('\n');
+    const parsed = JSON.parse(combined);
+    assert.ok(Array.isArray(parsed));
+    assert.ok(parsed.length > 0);
+    assert.ok(parsed[0].name);
+    assert.ok(parsed[0].type);
+  });
+});

package/test/commands/ping.test.js

@@ -0,0 +1,155 @@
+'use strict';
+
+const { describe, it, beforeEach, afterEach, mock } = require('node:test');
+const assert = require('node:assert/strict');
+const { Command } = require('commander');
+const { registerPing } = require('../../src/commands/ping');
+
+describe('ping command', () => {
+  let originalLog;
+  let originalError;
+  let originalExit;
+  let originalKey;
+  let originalMongoUri;
+  let output;
+  let errorOutput;
+
+  beforeEach(() => {
+    originalLog = console.log;
+    originalError = console.error;
+    originalExit = process.exit;
+    originalKey = process.env.VOYAGE_API_KEY;
+    originalMongoUri = process.env.MONGODB_URI;
+    output = [];
+    errorOutput = [];
+    console.log = (...args) => output.push(args.join(' '));
+    console.error = (...args) => errorOutput.push(args.join(' '));
+    // Remove MONGODB_URI by default so we don't accidentally test mongo
+    delete process.env.MONGODB_URI;
+  });
+
+  afterEach(() => {
+    console.log = originalLog;
+    console.error = originalError;
+    process.exit = originalExit;
+    if (originalKey !== undefined) {
+      process.env.VOYAGE_API_KEY = originalKey;
+    } else {
+      delete process.env.VOYAGE_API_KEY;
+    }
+    if (originalMongoUri !== undefined) {
+      process.env.MONGODB_URI = originalMongoUri;
+    } else {
+      delete process.env.MONGODB_URI;
+    }
+    mock.restoreAll();
+  });
+
+  it('registers correctly on a program', () => {
+    const program = new Command();
+    registerPing(program);
+    const pingCmd = program.commands.find(c => c.name() === 'ping');
+    assert.ok(pingCmd, 'ping command should be registered');
+  });
+
+  it('prints success on valid API response', async () => {
+    process.env.VOYAGE_API_KEY = 'test-key';
+
+    mock.method(global, 'fetch', async () => ({
+      ok: true,
+      status: 200,
+      json: async () => ({
+        data: [{ embedding: new Array(1024).fill(0) }],
+        usage: { total_tokens: 1 },
+      }),
+    }));
+
+    const program = new Command();
+    program.exitOverride();
+    registerPing(program);
+
+    await program.parseAsync(['node', 'test', 'ping']);
+
+    const combined = output.join('\n');
+    assert.ok(combined.includes('✓ Connected to Voyage AI API'), 'Should show success message');
+    assert.ok(combined.includes('voyage-4-lite'), 'Should show model name');
+    assert.ok(combined.includes('1024'), 'Should show dimensions');
+  });
+
+  it('exits with error on auth failure', async () => {
+    process.env.VOYAGE_API_KEY = 'bad-key';
+
+    mock.method(global, 'fetch', async () => ({
+      ok: false,
+      status: 401,
+      text: async () => 'Unauthorized',
+    }));
+
+    let exitCode = null;
+    process.exit = (code) => {
+      exitCode = code;
+      throw new Error('process.exit called');
+    };
+
+    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('Authentication failed'), 'Should show auth error');
+  });
+
+  it('exits when VOYAGE_API_KEY is not set', async () => {
+    delete process.env.VOYAGE_API_KEY;
+
+    let exitCode = null;
+    process.exit = (code) => {
+      exitCode = code;
+      throw new Error('process.exit called');
+    };
+
+    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');
+  });
+
+  it('outputs JSON when --json flag is used', async () => {
+    process.env.VOYAGE_API_KEY = 'test-key';
+
+    mock.method(global, 'fetch', async () => ({
+      ok: true,
+      status: 200,
+      json: async () => ({
+        data: [{ embedding: new Array(1024).fill(0) }],
+        usage: { total_tokens: 1 },
+      }),
+    }));
+
+    const program = new Command();
+    program.exitOverride();
+    registerPing(program);
+
+    await program.parseAsync(['node', 'test', 'ping', '--json']);
+
+    const combined = output.join('\n');
+    const parsed = JSON.parse(combined);
+    assert.equal(parsed.ok, true);
+    assert.ok(parsed.voyage);
+    assert.equal(parsed.voyage.ok, true);
+  });
+});

package/test/lib/api.test.js

@@ -0,0 +1,125 @@
+'use strict';
+
+const { describe, it, beforeEach, afterEach, mock } = require('node:test');
+const assert = require('node:assert/strict');
+
+describe('api', () => {
+  let originalKey;
+  let originalExit;
+
+  beforeEach(() => {
+    originalKey = process.env.VOYAGE_API_KEY;
+    originalExit = process.exit;
+  });
+
+  afterEach(() => {
+    if (originalKey !== undefined) {
+      process.env.VOYAGE_API_KEY = originalKey;
+    } else {
+      delete process.env.VOYAGE_API_KEY;
+    }
+    process.exit = originalExit;
+    mock.restoreAll();
+  });
+
+  describe('requireApiKey', () => {
+    it('throws/exits when VOYAGE_API_KEY is not set', () => {
+      delete process.env.VOYAGE_API_KEY;
+      // Re-require to get fresh module
+      delete require.cache[require.resolve('../../src/lib/api')];
+      const { requireApiKey } = require('../../src/lib/api');
+
+      let exitCode = null;
+      process.exit = (code) => {
+        exitCode = code;
+        throw new Error('process.exit called');
+      };
+
+      assert.throws(() => requireApiKey(), /process\.exit called/);
+      assert.equal(exitCode, 1);
+    });
+
+    it('returns key when VOYAGE_API_KEY is set', () => {
+      process.env.VOYAGE_API_KEY = 'test-key-123';
+      delete require.cache[require.resolve('../../src/lib/api')];
+      const { requireApiKey } = require('../../src/lib/api');
+
+      const key = requireApiKey();
+      assert.equal(key, 'test-key-123');
+    });
+  });
+
+  describe('apiRequest', () => {
+    it('returns parsed JSON on success', async () => {
+      process.env.VOYAGE_API_KEY = 'test-key';
+      delete require.cache[require.resolve('../../src/lib/api')];
+      const { apiRequest } = require('../../src/lib/api');
+
+      const mockResponse = {
+        ok: true,
+        status: 200,
+        json: async () => ({ data: [{ embedding: [1, 2, 3] }] }),
+        headers: new Map(),
+      };
+      mock.method(global, 'fetch', async () => mockResponse);
+
+      const result = await apiRequest('/embeddings', { input: ['test'], model: 'voyage-4-lite' });
+      assert.deepEqual(result, { data: [{ embedding: [1, 2, 3] }] });
+    });
+
+    it('exits on non-200 response', async () => {
+      process.env.VOYAGE_API_KEY = 'test-key';
+      delete require.cache[require.resolve('../../src/lib/api')];
+      const { apiRequest } = require('../../src/lib/api');
+
+      let exitCode = null;
+      process.exit = (code) => {
+        exitCode = code;
+        throw new Error('process.exit called');
+      };
+
+      const mockResponse = {
+        ok: false,
+        status: 400,
+        json: async () => ({ detail: 'Bad request' }),
+        headers: new Map(),
+      };
+      mock.method(global, 'fetch', async () => mockResponse);
+
+      await assert.rejects(
+        () => apiRequest('/embeddings', { input: ['test'], model: 'voyage-4-lite' }),
+        /process\.exit called/
+      );
+      assert.equal(exitCode, 1);
+    });
+
+    it('retries on 429', async () => {
+      process.env.VOYAGE_API_KEY = 'test-key';
+      delete require.cache[require.resolve('../../src/lib/api')];
+      const { apiRequest } = require('../../src/lib/api');
+
+      let callCount = 0;
+      mock.method(global, 'fetch', async () => {
+        callCount++;
+        if (callCount === 1) {
+          return {
+            ok: false,
+            status: 429,
+            headers: { get: () => '0' },
+            json: async () => ({ detail: 'Rate limited' }),
+          };
+        }
+        return {
+          ok: true,
+          status: 200,
+          json: async () => ({ data: 'success' }),
+          headers: new Map(),
+        };
+      });
+
+      const result = await apiRequest('/embeddings', { input: ['test'], model: 'voyage-4-lite' });
+      assert.deepEqual(result, { data: 'success' });
+      assert.equal(callCount, 2, 'Should have retried once');
+    });
+  });
+});

package/test/lib/banner.test.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const { describe, it, beforeEach, afterEach } = require('node:test');
+const assert = require('node:assert/strict');
+const { showBanner, showQuickStart, getVersion } = require('../../src/lib/banner');
+
+describe('banner', () => {
+  let originalLog;
+  let output;
+
+  beforeEach(() => {
+    originalLog = console.log;
+    output = [];
+    console.log = (...args) => output.push(args.join(' '));
+  });
+
+  afterEach(() => {
+    console.log = originalLog;
+  });
+
+  it('getVersion returns a semver string', () => {
+    const version = getVersion();
+    assert.ok(/^\d+\.\d+\.\d+/.test(version), `Expected semver, got: ${version}`);
+  });
+
+  it('showBanner prints box with vai and Voyage AI CLI', () => {
+    showBanner();
+    const combined = output.join('\n');
+    assert.ok(combined.includes('vai'), 'Should include "vai"');
+    assert.ok(combined.includes('Voyage AI CLI'), 'Should include "Voyage AI CLI"');
+    assert.ok(combined.includes('╭'), 'Should include top border');
+    assert.ok(combined.includes('╰'), 'Should include bottom border');
+  });
+
+  it('showQuickStart prints quick start commands', () => {
+    showQuickStart();
+    const combined = output.join('\n');
+    assert.ok(combined.includes('Quick start'), 'Should include header');
+    assert.ok(combined.includes('vai ping'), 'Should include ping');
+    assert.ok(combined.includes('vai embed'), 'Should include embed');
+    assert.ok(combined.includes('vai models'), 'Should include models');
+    assert.ok(combined.includes('vai demo'), 'Should include demo');
+  });
+});