voyageai-cli 1.24.0 → 1.26.1

package/src/lib/templates/nextjs/theme.js.tpl

@@ -1,84 +1,157 @@
 /**
- * MUI Theme Configuration
+ * MUI Theme Configuration — vai branded
  * Generated by vai v{{vaiVersion}} on {{generatedAt}}
  */
 
 'use client';
 
-import { createTheme } from '@mui/material/styles';
+import { createTheme, responsiveFontSizes } from '@mui/material/styles';
 
-// MongoDB-inspired color palette
-const palette = {
-  primary: {
-    main: '#00ED64',      // MongoDB Green
-    light: '#4DFF94',
-    dark: '#00B84A',
-    contrastText: '#000',
-  },
-  secondary: {
-    main: '#001E2B',      // MongoDB Dark
-    light: '#1C3A4B',
-    dark: '#000F17',
-    contrastText: '#fff',
-  },
-  background: {
-    default: '#FAFAFA',
-    paper: '#FFFFFF',
-  },
-  text: {
-    primary: '#001E2B',
-    secondary: '#5C6C75',
-  },
+/* ── colour tokens ─────────────────────────────── */
+const brand = {
+  green:      '#00ED64',
+  greenLight: '#71F6A0',
+  greenDark:  '#00B84A',
+  navy:       '#001E2B',
+  navyLight:  '#1C3A4B',
+  slate:      '#3D4F58',
+  mist:       '#E3FCF7',
+  white:      '#FFFFFF',
+  offWhite:   '#F9FBFA',
+  grey100:    '#F5F6F7',
+  grey300:    '#C1C7C6',
+  grey500:    '#889397',
+  grey700:    '#5C6C75',
 };
 
-export const theme = createTheme({
-  palette,
-  typography: {
-    fontFamily: '"Inter", "Roboto", "Helvetica", "Arial", sans-serif',
-    h1: {
-      fontWeight: 700,
-    },
-    h2: {
-      fontWeight: 600,
-    },
-    h3: {
-      fontWeight: 600,
-    },
-    h4: {
-      fontWeight: 600,
+/* ── light palette ─────────────────────────────── */
+const lightPalette = {
+  mode: 'light',
+  primary:    { main: brand.green, light: brand.greenLight, dark: brand.greenDark, contrastText: brand.navy },
+  secondary:  { main: brand.navy,  light: brand.navyLight,  dark: '#000F17',      contrastText: brand.white },
+  background: { default: brand.offWhite, paper: brand.white },
+  text:       { primary: brand.navy, secondary: brand.grey700 },
+  divider:    brand.grey300,
+  success:    { main: brand.greenDark },
+};
+
+/* ── dark palette ──────────────────────────────── */
+const darkPalette = {
+  mode: 'dark',
+  primary:    { main: brand.green, light: brand.greenLight, dark: brand.greenDark, contrastText: brand.navy },
+  secondary:  { main: '#90CAF9', light: '#BBDEFB', dark: '#42A5F5', contrastText: brand.navy },
+  background: { default: '#0A1117', paper: '#111D27' },
+  text:       { primary: '#E8EDDF', secondary: '#9AABB8' },
+  divider:    'rgba(255,255,255,0.12)',
+  success:    { main: brand.green },
+};
+
+function buildTheme(mode = 'light') {
+  let theme = createTheme({
+    palette: mode === 'dark' ? darkPalette : lightPalette,
+    typography: {
+      fontFamily: '"Inter", "IBM Plex Sans", "Roboto", "Helvetica Neue", Arial, sans-serif',
+      h1: { fontWeight: 800, letterSpacing: '-0.02em' },
+      h2: { fontWeight: 700, letterSpacing: '-0.01em' },
+      h3: { fontWeight: 700 },
+      h4: { fontWeight: 700 },
+      h5: { fontWeight: 600 },
+      h6: { fontWeight: 600 },
+      subtitle1: { fontWeight: 500, color: mode === 'dark' ? '#9AABB8' : brand.grey700 },
+      button: { fontWeight: 600, textTransform: 'none' },
+      overline: { fontWeight: 700, letterSpacing: '0.08em' },
     },
-  },
-  shape: {
-    borderRadius: 8,
-  },
-  components: {
-    MuiButton: {
-      styleOverrides: {
-        root: {
-          textTransform: 'none',
-          fontWeight: 600,
+    shape: { borderRadius: 12 },
+    shadows: [
+      'none',
+      '0 1px 2px rgba(0,0,0,0.06)',
+      '0 1px 4px rgba(0,0,0,0.08)',
+      '0 2px 8px rgba(0,0,0,0.10)',
+      '0 4px 12px rgba(0,0,0,0.10)',
+      '0 6px 16px rgba(0,0,0,0.10)',
+      ...Array(19).fill('0 8px 24px rgba(0,0,0,0.12)'),
+    ],
+    components: {
+      MuiCssBaseline: {
+        styleOverrides: {
+          body: {
+            scrollbarWidth: 'thin',
+            '&::-webkit-scrollbar': { width: 6 },
+            '&::-webkit-scrollbar-thumb': { background: brand.grey300, borderRadius: 3 },
+          },
         },
-        contained: {
-          boxShadow: 'none',
-          '&:hover': {
-            boxShadow: 'none',
+      },
+      MuiButton: {
+        defaultProps: { disableElevation: true },
+        styleOverrides: {
+          root: { borderRadius: 8, padding: '8px 20px', fontWeight: 600 },
+          containedPrimary: {
+            color: brand.navy,
+            '&:hover': { background: brand.greenLight },
           },
+          outlined: { borderWidth: 2, '&:hover': { borderWidth: 2 } },
         },
       },
-    },
-    MuiCard: {
-      styleOverrides: {
-        root: {
-          boxShadow: '0 1px 3px rgba(0,0,0,0.12), 0 1px 2px rgba(0,0,0,0.06)',
+      MuiCard: {
+        styleOverrides: {
+          root: {
+            borderRadius: 16,
+            border: `1px solid ${mode === 'dark' ? 'rgba(255,255,255,0.08)' : brand.grey100}`,
+            transition: 'box-shadow 0.2s ease, transform 0.2s ease',
+            '&:hover': {
+              boxShadow: mode === 'dark'
+                ? '0 8px 24px rgba(0,237,100,0.08)'
+                : '0 8px 24px rgba(0,0,0,0.08)',
+              transform: 'translateY(-2px)',
+            },
+          },
         },
       },
-    },
-    MuiChip: {
-      styleOverrides: {
-        root: {
-          fontWeight: 500,
+      MuiChip: {
+        styleOverrides: {
+          root: { fontWeight: 600, borderRadius: 8 },
+          colorSuccess: {
+            background: mode === 'dark' ? 'rgba(0,237,100,0.15)' : brand.mist,
+            color: mode === 'dark' ? brand.green : brand.greenDark,
+          },
+        },
+      },
+      MuiTextField: {
+        styleOverrides: {
+          root: {
+            '& .MuiOutlinedInput-root': {
+              borderRadius: 12,
+              '&.Mui-focused .MuiOutlinedInput-notchedOutline': {
+                borderColor: brand.green,
+                borderWidth: 2,
+              },
+            },
+          },
+        },
+      },
+      MuiAppBar: {
+        styleOverrides: {
+          root: {
+            background: mode === 'dark' ? '#0D1820' : brand.white,
+            borderBottom: `1px solid ${mode === 'dark' ? 'rgba(255,255,255,0.08)' : brand.grey100}`,
+          },
+        },
+      },
+      MuiLinearProgress: {
+        styleOverrides: {
+          root: { borderRadius: 4, height: 6 },
+          bar: { borderRadius: 4 },
         },
       },
     },
-  },
-});
+  });
+
+  theme = responsiveFontSizes(theme);
+  return theme;
+}
+
+export const lightTheme = buildTheme('light');
+export const darkTheme  = buildTheme('dark');
+
+/* default export for simple usage */
+export const theme = lightTheme;

package/src/lib/tool-registry.js

@@ -0,0 +1,194 @@
+'use strict';
+
+/**
+ * Tool Registry
+ *
+ * Single source of truth mapping MCP Zod schemas to LLM tool definitions
+ * and dispatching tool execution. Bridges the MCP tool handlers with the
+ * agent chat loop.
+ */
+
+const { z } = require('zod');
+const schemas = require('../mcp/schemas');
+
+// Lazy-loaded handlers to avoid circular deps
+let _handlers;
+function getHandlers() {
+  if (!_handlers) {
+    const { handleVaiQuery, handleVaiSearch, handleVaiRerank } = require('../mcp/tools/retrieval');
+    const { handleVaiEmbed, handleVaiSimilarity } = require('../mcp/tools/embedding');
+    const { handleVaiCollections, handleVaiModels } = require('../mcp/tools/management');
+    const { handleVaiTopics, handleVaiExplain, handleVaiEstimate } = require('../mcp/tools/utility');
+    const { handleVaiIngest } = require('../mcp/tools/ingest');
+
+    _handlers = {
+      vai_query: handleVaiQuery,
+      vai_search: handleVaiSearch,
+      vai_rerank: handleVaiRerank,
+      vai_embed: handleVaiEmbed,
+      vai_similarity: handleVaiSimilarity,
+      vai_collections: handleVaiCollections,
+      vai_models: handleVaiModels,
+      vai_topics: handleVaiTopics,
+      vai_explain: handleVaiExplain,
+      vai_estimate: handleVaiEstimate,
+      vai_ingest: handleVaiIngest,
+    };
+  }
+  return _handlers;
+}
+
+/**
+ * Tool definitions: name, description, and schema key for each tool.
+ */
+const TOOL_DEFINITIONS = [
+  {
+    name: 'vai_query',
+    description: 'Full RAG query: embeds the question with Voyage AI, runs vector search against MongoDB Atlas, and reranks results. Use this when you need to answer a question using the knowledge base.',
+    schemaKey: 'querySchema',
+  },
+  {
+    name: 'vai_search',
+    description: 'Raw vector similarity search without reranking. Faster than vai_query but results are ordered by vector distance only. Use for exploratory searches or when you plan to rerank separately.',
+    schemaKey: 'searchSchema',
+  },
+  {
+    name: 'vai_rerank',
+    description: 'Rerank documents against a query using Voyage AI reranker. Takes a query and candidate documents, returns them reordered by relevance.',
+    schemaKey: 'rerankSchema',
+  },
+  {
+    name: 'vai_embed',
+    description: 'Embed text using a Voyage AI model and return the vector representation. Use for custom similarity logic, storing vectors, or debugging.',
+    schemaKey: 'embedSchema',
+  },
+  {
+    name: 'vai_similarity',
+    description: 'Compare two texts semantically by embedding both and computing cosine similarity. Returns a score from -1 to 1.',
+    schemaKey: 'similaritySchema',
+  },
+  {
+    name: 'vai_collections',
+    description: 'List available MongoDB collections with document counts and vector index information. Use to discover which knowledge bases exist.',
+    schemaKey: 'collectionsSchema',
+  },
+  {
+    name: 'vai_models',
+    description: 'List available Voyage AI models with capabilities and pricing. Use when selecting a model or comparing options.',
+    schemaKey: 'modelsSchema',
+  },
+  {
+    name: 'vai_topics',
+    description: 'List all available educational topics. Call this to discover what vai can explain.',
+    schemaKey: 'topicsSchema',
+  },
+  {
+    name: 'vai_explain',
+    description: 'Get a detailed explanation of a topic (embeddings, vector search, RAG, MoE, etc). Supports fuzzy matching.',
+    schemaKey: 'explainSchema',
+  },
+  {
+    name: 'vai_estimate',
+    description: 'Estimate costs for Voyage AI embedding and query operations at various scales.',
+    schemaKey: 'estimateSchema',
+  },
+  {
+    name: 'vai_ingest',
+    description: 'Add a document to a collection: chunks the text, embeds each chunk with Voyage AI, and stores in MongoDB Atlas.',
+    schemaKey: 'ingestSchema',
+  },
+];
+
+/**
+ * Convert a Zod schema fields object (as used in MCP schemas) to JSON Schema.
+ * Strips fields with defaults from the required array so the LLM doesn't
+ * have to provide them.
+ *
+ * @param {object} zodFields - Plain object of Zod field definitions
+ * @returns {object} JSON Schema object
+ */
+function zodSchemaToJsonSchema(zodFields) {
+  const obj = z.object(zodFields);
+  const jsonSchema = z.toJSONSchema(obj);
+
+  // Remove $schema key (not needed for tool definitions)
+  delete jsonSchema['$schema'];
+
+  // Strip fields with 'default' from required array.
+  // LLMs should not be forced to provide values that have defaults.
+  if (jsonSchema.required && jsonSchema.properties) {
+    jsonSchema.required = jsonSchema.required.filter(key => {
+      const prop = jsonSchema.properties[key];
+      return prop && !('default' in prop);
+    });
+    if (jsonSchema.required.length === 0) delete jsonSchema.required;
+  }
+
+  return jsonSchema;
+}
+
+/**
+ * Get tool definitions formatted for a specific LLM provider.
+ *
+ * @param {'anthropic'|'openai'|'ollama'} format - Provider format
+ * @returns {Array} Tool definitions in provider-specific format
+ */
+function getToolDefinitions(format) {
+  return TOOL_DEFINITIONS.map(def => {
+    const zodFields = schemas[def.schemaKey];
+    const inputSchema = zodSchemaToJsonSchema(zodFields);
+
+    if (format === 'anthropic') {
+      return {
+        name: def.name,
+        description: def.description,
+        input_schema: inputSchema,
+      };
+    }
+
+    // OpenAI / Ollama format
+    return {
+      type: 'function',
+      function: {
+        name: def.name,
+        description: def.description,
+        parameters: inputSchema,
+      },
+    };
+  });
+}
+
+/**
+ * Execute a tool by name with the given arguments.
+ * Validates args against the Zod schema, then calls the handler.
+ *
+ * @param {string} name - Tool name (e.g. 'vai_query')
+ * @param {object} args - Tool arguments
+ * @returns {Promise<{structuredContent: object, content: Array}>}
+ */
+async function executeTool(name, args) {
+  const handlers = getHandlers();
+  const handler = handlers[name];
+  if (!handler) {
+    throw new Error(`Unknown tool: "${name}". Available: ${Object.keys(handlers).join(', ')}`);
+  }
+
+  // Find the schema for validation
+  const def = TOOL_DEFINITIONS.find(d => d.name === name);
+  if (!def) throw new Error(`No schema found for tool: "${name}"`);
+
+  const zodFields = schemas[def.schemaKey];
+  const zodObj = z.object(zodFields);
+
+  // Validate and apply defaults
+  const validated = zodObj.parse(args);
+
+  return handler(validated);
+}
+
+module.exports = {
+  TOOL_DEFINITIONS,
+  zodSchemaToJsonSchema,
+  getToolDefinitions,
+  executeTool,
+};

package/src/lib/workflow-utils.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const { requireMongoUri } = require('./mongo');
+
+/**
+ * Introspect MongoDB collections: list collections with vector index info.
+ * Moved from src/mcp/tools/management.js for reuse by the workflow engine.
+ *
+ * @param {string} dbName
+ * @returns {Promise<Array<{ name: string, documentCount: number, hasVectorIndex: boolean, embeddingField?: string, dimensions?: number }>>}
+ */
+async function introspectCollections(dbName) {
+  const { MongoClient } = require('mongodb');
+  const uri = requireMongoUri();
+  const client = new MongoClient(uri);
+  await client.connect();
+
+  try {
+    const db = client.db(dbName);
+    const collections = await db.listCollections().toArray();
+    const results = [];
+
+    for (const collInfo of collections) {
+      if (collInfo.name.startsWith('system.')) continue;
+      const coll = db.collection(collInfo.name);
+      const documentCount = await coll.estimatedDocumentCount();
+
+      let hasVectorIndex = false;
+      let embeddingField;
+      let dimensions;
+
+      try {
+        const indexes = await coll.listSearchIndexes().toArray();
+        for (const idx of indexes) {
+          const fields = idx.latestDefinition?.fields || [];
+          for (const f of fields) {
+            if (f.type === 'vector') {
+              hasVectorIndex = true;
+              embeddingField = f.path;
+              dimensions = f.numDimensions;
+              break;
+            }
+          }
+          if (hasVectorIndex) break;
+        }
+      } catch {
+        // listSearchIndexes may not be available on non-Atlas deployments
+      }
+
+      results.push({
+        name: collInfo.name,
+        documentCount,
+        hasVectorIndex,
+        ...(embeddingField && { embeddingField }),
+        ...(dimensions && { dimensions }),
+      });
+    }
+
+    return results;
+  } finally {
+    await client.close();
+  }
+}
+
+module.exports = { introspectCollections };