mdcontext 0.0.1 → 0.2.0

package/src/embeddings/heading-boost.test.ts

@@ -0,0 +1,222 @@
+/**
+ * Heading Match Boost Tests
+ *
+ * Tests for heading boost functionality that improves search results
+ * when query terms appear in section headings.
+ */
+
+import { describe, expect, it } from 'vitest'
+import {
+  calculateFileImportanceBoost,
+  calculateHeadingBoost,
+  calculateRankingBoost,
+  type SemanticSearchOptions,
+} from './types.js'
+
+describe('Heading Match Boost', () => {
+  describe('calculateHeadingBoost function', () => {
+    it('should return 0 for no matches', () => {
+      expect(
+        calculateHeadingBoost('Installation Guide', 'authentication'),
+      ).toBe(0)
+    })
+
+    it('should return boost for single term match', () => {
+      expect(calculateHeadingBoost('Installation Guide', 'installation')).toBe(
+        0.05,
+      )
+    })
+
+    it('should return higher boost for multiple term matches', () => {
+      expect(
+        calculateHeadingBoost('Installation Guide', 'installation guide'),
+      ).toBe(0.1)
+    })
+
+    it('should be case-insensitive', () => {
+      expect(
+        calculateHeadingBoost('INSTALLATION GUIDE', 'installation guide'),
+      ).toBe(0.1)
+      expect(
+        calculateHeadingBoost('Installation Guide', 'INSTALLATION GUIDE'),
+      ).toBe(0.1)
+    })
+
+    it('should handle partial term matches', () => {
+      // "install" is contained in "Installation"
+      expect(calculateHeadingBoost('Installation Guide', 'install')).toBe(0.05)
+    })
+
+    it('should handle empty query', () => {
+      expect(calculateHeadingBoost('Installation Guide', '')).toBe(0)
+    })
+
+    it('should handle empty heading', () => {
+      expect(calculateHeadingBoost('', 'installation')).toBe(0)
+    })
+
+    it('should handle whitespace-only query', () => {
+      expect(calculateHeadingBoost('Installation Guide', '   ')).toBe(0)
+    })
+
+    it('should boost navigation queries', () => {
+      // Common navigation patterns
+      expect(calculateHeadingBoost('API Reference', 'api reference')).toBe(0.1)
+      expect(calculateHeadingBoost('Getting Started', 'getting started')).toBe(
+        0.1,
+      )
+      expect(calculateHeadingBoost('Configuration', 'config')).toBe(0.05)
+    })
+
+    it('should count each matching term only once', () => {
+      // Query with repeated terms - each "auth" matches "authentication"
+      expect(
+        calculateHeadingBoost('Authentication', 'auth auth auth'),
+      ).toBeCloseTo(0.15)
+    })
+  })
+
+  describe('SemanticSearchOptions headingBoost', () => {
+    it('should accept headingBoost option', () => {
+      const options: SemanticSearchOptions = {
+        headingBoost: true,
+      }
+      expect(options.headingBoost).toBe(true)
+    })
+
+    it('should accept headingBoost=false to disable', () => {
+      const options: SemanticSearchOptions = {
+        headingBoost: false,
+      }
+      expect(options.headingBoost).toBe(false)
+    })
+
+    it('should default to undefined (enabled)', () => {
+      const options: SemanticSearchOptions = {}
+      expect(options.headingBoost).toBeUndefined()
+    })
+
+    it('should work with other options', () => {
+      const options: SemanticSearchOptions = {
+        limit: 10,
+        threshold: 0.35,
+        headingBoost: true,
+        skipPreprocessing: false,
+      }
+      expect(options.headingBoost).toBe(true)
+      expect(options.limit).toBe(10)
+    })
+  })
+})
+
+describe('File Importance Boost', () => {
+  describe('calculateFileImportanceBoost function', () => {
+    it('should return boost for README files', () => {
+      expect(calculateFileImportanceBoost('README.md')).toBe(0.03)
+      expect(calculateFileImportanceBoost('docs/README.md')).toBe(0.03)
+      expect(calculateFileImportanceBoost('readme.md')).toBe(0.03)
+    })
+
+    it('should return boost for index files', () => {
+      expect(calculateFileImportanceBoost('index.md')).toBe(0.03)
+      expect(calculateFileImportanceBoost('docs/index.md')).toBe(0.03)
+    })
+
+    it('should return boost for getting started guides', () => {
+      expect(calculateFileImportanceBoost('getting-started.md')).toBe(0.03)
+      expect(calculateFileImportanceBoost('Getting-Started.md')).toBe(0.03)
+      expect(calculateFileImportanceBoost('gettingstarted.md')).toBe(0.03)
+    })
+
+    it('should return boost for introduction files', () => {
+      expect(calculateFileImportanceBoost('introduction.md')).toBe(0.03)
+      expect(calculateFileImportanceBoost('docs/introduction.md')).toBe(0.03)
+    })
+
+    it('should return boost for overview files', () => {
+      expect(calculateFileImportanceBoost('overview.md')).toBe(0.03)
+      expect(calculateFileImportanceBoost('docs/overview.md')).toBe(0.03)
+    })
+
+    it('should return boost for quickstart guides', () => {
+      expect(calculateFileImportanceBoost('quickstart.md')).toBe(0.03)
+      expect(calculateFileImportanceBoost('Quickstart.md')).toBe(0.03)
+    })
+
+    it('should return boost for changelog files', () => {
+      expect(calculateFileImportanceBoost('CHANGELOG.md')).toBe(0.03)
+      expect(calculateFileImportanceBoost('changelog.md')).toBe(0.03)
+    })
+
+    it('should return 0 for regular files', () => {
+      expect(calculateFileImportanceBoost('api.md')).toBe(0)
+      expect(calculateFileImportanceBoost('docs/configuration.md')).toBe(0)
+      expect(calculateFileImportanceBoost('src/utils.md')).toBe(0)
+    })
+  })
+
+  describe('calculateRankingBoost combined function', () => {
+    it('should combine heading and file importance boosts', () => {
+      // README with matching heading
+      const boost = calculateRankingBoost(
+        'Installation Guide',
+        'installation',
+        'README.md',
+      )
+      expect(boost).toBe(0.08) // 0.05 (heading) + 0.03 (file)
+    })
+
+    it('should return only file boost when heading does not match', () => {
+      const boost = calculateRankingBoost(
+        'API Reference',
+        'authentication',
+        'README.md',
+      )
+      expect(boost).toBe(0.03) // 0.00 (heading) + 0.03 (file)
+    })
+
+    it('should return only heading boost for regular files', () => {
+      const boost = calculateRankingBoost(
+        'Installation Guide',
+        'installation',
+        'docs/install.md',
+      )
+      expect(boost).toBe(0.05) // 0.05 (heading) + 0.00 (file)
+    })
+
+    it('should return 0 when nothing matches', () => {
+      const boost = calculateRankingBoost(
+        'API Reference',
+        'authentication',
+        'docs/api.md',
+      )
+      expect(boost).toBe(0)
+    })
+  })
+})
+
+describe('Export verification', () => {
+  it('should export calculateHeadingBoost from types module', async () => {
+    const { calculateHeadingBoost } = await import('./types.js')
+    expect(calculateHeadingBoost).toBeDefined()
+    expect(typeof calculateHeadingBoost).toBe('function')
+  })
+
+  it('should export calculateHeadingBoost from main embeddings module', async () => {
+    const { calculateHeadingBoost } = await import('./index.js')
+    expect(calculateHeadingBoost).toBeDefined()
+    expect(typeof calculateHeadingBoost).toBe('function')
+  })
+
+  it('should export calculateFileImportanceBoost from types module', async () => {
+    const { calculateFileImportanceBoost } = await import('./types.js')
+    expect(calculateFileImportanceBoost).toBeDefined()
+    expect(typeof calculateFileImportanceBoost).toBe('function')
+  })
+
+  it('should export calculateFileImportanceBoost from main embeddings module', async () => {
+    const { calculateFileImportanceBoost } = await import('./index.js')
+    expect(calculateFileImportanceBoost).toBeDefined()
+    expect(typeof calculateFileImportanceBoost).toBe('function')
+  })
+})

package/src/embeddings/hnsw-build-options.test.ts

@@ -0,0 +1,198 @@
+/**
+ * HNSW Build Options Tests
+ *
+ * Tests for configurable HNSW index build parameters:
+ * - M: maximum connections per node (affects recall and index size)
+ * - efConstruction: construction-time search width (affects quality and build time)
+ *
+ * These parameters control the vector index structure and require index rebuild when changed.
+ */
+
+import * as path from 'node:path'
+import { Effect } from 'effect'
+import { describe, expect, it } from 'vitest'
+import {
+  createNamespacedVectorStore,
+  createVectorStore,
+  type HnswBuildOptions,
+} from './vector-store.js'
+
+// Path to test corpus with pre-built embeddings
+const TEST_CORPUS_PATH = path.join(
+  __dirname,
+  '../__tests__/fixtures/semantic-search/multi-word-corpus',
+)
+
+// Test corpus uses 512 dimensions (text-embedding-3-small with Matryoshka reduction)
+const TEST_CORPUS_DIMENSIONS = 512
+const TEST_CORPUS_PROVIDER = 'openai'
+const TEST_CORPUS_MODEL = 'text-embedding-3-small'
+
+// Helper to create the namespaced vector store for test corpus
+const createTestVectorStore = (hnswOptions?: HnswBuildOptions) =>
+  createNamespacedVectorStore(
+    TEST_CORPUS_PATH,
+    TEST_CORPUS_PROVIDER,
+    TEST_CORPUS_MODEL,
+    TEST_CORPUS_DIMENSIONS,
+    hnswOptions,
+  )
+
+describe('HNSW Build Options', () => {
+  describe('HnswBuildOptions interface', () => {
+    it('should accept M parameter', () => {
+      const options: HnswBuildOptions = { m: 24 }
+      expect(options.m).toBe(24)
+    })
+
+    it('should accept efConstruction parameter', () => {
+      const options: HnswBuildOptions = { efConstruction: 256 }
+      expect(options.efConstruction).toBe(256)
+    })
+
+    it('should accept both parameters', () => {
+      const options: HnswBuildOptions = { m: 24, efConstruction: 256 }
+      expect(options.m).toBe(24)
+      expect(options.efConstruction).toBe(256)
+    })
+
+    it('should allow undefined parameters for defaults', () => {
+      const options: HnswBuildOptions = {}
+      expect(options.m).toBeUndefined()
+      expect(options.efConstruction).toBeUndefined()
+    })
+  })
+
+  describe('createVectorStore with HNSW options', () => {
+    it('should create vector store without HNSW options (defaults)', () => {
+      const vectorStore = createVectorStore(
+        TEST_CORPUS_PATH,
+        TEST_CORPUS_DIMENSIONS,
+      )
+      expect(vectorStore).toBeDefined()
+      expect(vectorStore.dimensions).toBe(TEST_CORPUS_DIMENSIONS)
+    })
+
+    it('should create vector store with custom M parameter', () => {
+      const vectorStore = createVectorStore(
+        TEST_CORPUS_PATH,
+        TEST_CORPUS_DIMENSIONS,
+        { m: 24 },
+      )
+      expect(vectorStore).toBeDefined()
+      expect(vectorStore.dimensions).toBe(TEST_CORPUS_DIMENSIONS)
+    })
+
+    it('should create vector store with custom efConstruction parameter', () => {
+      const vectorStore = createVectorStore(
+        TEST_CORPUS_PATH,
+        TEST_CORPUS_DIMENSIONS,
+        { efConstruction: 256 },
+      )
+      expect(vectorStore).toBeDefined()
+      expect(vectorStore.dimensions).toBe(TEST_CORPUS_DIMENSIONS)
+    })
+
+    it('should create vector store with both custom parameters', () => {
+      const vectorStore = createVectorStore(
+        TEST_CORPUS_PATH,
+        TEST_CORPUS_DIMENSIONS,
+        { m: 24, efConstruction: 256 },
+      )
+      expect(vectorStore).toBeDefined()
+      expect(vectorStore.dimensions).toBe(TEST_CORPUS_DIMENSIONS)
+    })
+  })
+
+  describe('Recommended configurations', () => {
+    it('should support speed-focused config (M=12, efConstruction=128)', () => {
+      const speedOptions: HnswBuildOptions = { m: 12, efConstruction: 128 }
+      const vectorStore = createVectorStore(
+        TEST_CORPUS_PATH,
+        TEST_CORPUS_DIMENSIONS,
+        speedOptions,
+      )
+      expect(vectorStore).toBeDefined()
+    })
+
+    it('should support balanced config (M=16, efConstruction=200) - defaults', () => {
+      // Default config - no options passed
+      const vectorStore = createVectorStore(
+        TEST_CORPUS_PATH,
+        TEST_CORPUS_DIMENSIONS,
+      )
+      expect(vectorStore).toBeDefined()
+    })
+
+    it('should support quality-focused config (M=24, efConstruction=256)', () => {
+      const qualityOptions: HnswBuildOptions = { m: 24, efConstruction: 256 }
+      const vectorStore = createVectorStore(
+        TEST_CORPUS_PATH,
+        TEST_CORPUS_DIMENSIONS,
+        qualityOptions,
+      )
+      expect(vectorStore).toBeDefined()
+    })
+  })
+
+  describe('Vector store functionality with custom options', () => {
+    it('should load existing index regardless of HNSW options', async () => {
+      // HNSW options only affect index creation, not loading
+      const vectorStore = createTestVectorStore({ m: 24, efConstruction: 256 })
+      const loadResult = await Effect.runPromise(vectorStore.load())
+      expect(loadResult.loaded).toBe(true)
+
+      const stats = vectorStore.getStats()
+      expect(stats.count).toBeGreaterThan(0)
+    })
+
+    it('should search after loading with custom options', async () => {
+      const vectorStore = createTestVectorStore({ m: 12, efConstruction: 128 })
+      await Effect.runPromise(vectorStore.load())
+
+      const results = await Effect.runPromise(
+        vectorStore.search(new Array(TEST_CORPUS_DIMENSIONS).fill(0.1), 10, 0),
+      )
+
+      expect(results.length).toBeGreaterThan(0)
+    })
+  })
+
+  describe('Config schema HNSW defaults', () => {
+    it('should have hnswM default of 16 in config schema', async () => {
+      const { defaultConfig } = await import('../config/schema.js')
+      expect(defaultConfig.embeddings.hnswM).toBe(16)
+    })
+
+    it('should have hnswEfConstruction default of 200 in config schema', async () => {
+      const { defaultConfig } = await import('../config/schema.js')
+      expect(defaultConfig.embeddings.hnswEfConstruction).toBe(200)
+    })
+  })
+})
+
+describe('BuildEmbeddingsOptions HNSW support', () => {
+  it('should export BuildEmbeddingsOptions with hnswOptions field', async () => {
+    const { buildEmbeddings } = await import('./semantic-search.js')
+    expect(buildEmbeddings).toBeDefined()
+    expect(typeof buildEmbeddings).toBe('function')
+  })
+
+  it('should accept hnswOptions in BuildEmbeddingsOptions interface', async () => {
+    // Type-level test: if this compiles, the interface has the field
+    type BuildEmbeddingsOptions =
+      typeof import('./semantic-search.js').buildEmbeddings extends (
+        path: string,
+        options?: infer O,
+      ) => unknown
+        ? O
+        : never
+
+    // This verifies the type accepts hnswOptions
+    const options: BuildEmbeddingsOptions = {
+      hnswOptions: { m: 24, efConstruction: 256 },
+    }
+    expect(options.hnswOptions?.m).toBe(24)
+    expect(options.hnswOptions?.efConstruction).toBe(256)
+  })
+})

package/src/embeddings/hyde.test.ts

@@ -0,0 +1,272 @@
+/**
+ * HyDE (Hypothetical Document Embeddings) Tests
+ *
+ * Tests for HyDE query expansion functionality.
+ */
+
+import { Effect } from 'effect'
+import { describe, expect, it } from 'vitest'
+import {
+  generateHypotheticalDocument,
+  type HydeOptions,
+  type HydeResult,
+  isHydeAvailable,
+  shouldUseHyde,
+} from './hyde.js'
+import type { SemanticSearchOptions } from './types.js'
+
+describe('HyDE Query Expansion', () => {
+  describe('shouldUseHyde detection', () => {
+    it('should recommend HyDE for question queries', () => {
+      expect(shouldUseHyde('How do I configure authentication?')).toBe(true)
+      expect(shouldUseHyde('What is the best way to handle errors?')).toBe(true)
+      expect(shouldUseHyde('Why is my build failing?')).toBe(true)
+      expect(shouldUseHyde('When should I use caching?')).toBe(true)
+      expect(shouldUseHyde('Where are the configuration files?')).toBe(true)
+    })
+
+    it('should recommend HyDE for procedural queries', () => {
+      expect(shouldUseHyde('setup react project with typescript')).toBe(true)
+      expect(shouldUseHyde('install dependencies for the project')).toBe(true)
+      expect(shouldUseHyde('configure webpack for production')).toBe(true)
+      expect(shouldUseHyde('implement user authentication flow')).toBe(true)
+    })
+
+    it('should recommend HyDE for longer queries (6+ words)', () => {
+      expect(
+        shouldUseHyde('user login flow with oauth and refresh tokens'),
+      ).toBe(true)
+      expect(
+        shouldUseHyde(
+          'database connection pooling configuration options for mysql',
+        ),
+      ).toBe(true)
+    })
+
+    it('should not recommend HyDE for short queries', () => {
+      expect(shouldUseHyde('api')).toBe(false)
+      expect(shouldUseHyde('config')).toBe(false)
+      expect(shouldUseHyde('user auth')).toBe(false)
+    })
+
+    it('should not recommend HyDE for exact phrase searches', () => {
+      expect(shouldUseHyde('"exact phrase match"')).toBe(false)
+    })
+
+    it('should recommend HyDE for queries ending with question mark', () => {
+      expect(shouldUseHyde('database configuration options?')).toBe(true)
+    })
+
+    it('should handle edge cases gracefully', () => {
+      expect(shouldUseHyde('')).toBe(false)
+      expect(shouldUseHyde('   ')).toBe(false)
+      expect(shouldUseHyde('a')).toBe(false)
+    })
+  })
+
+  describe('isHydeAvailable', () => {
+    it('should check if OPENAI_API_KEY is set', () => {
+      // This test reflects the actual environment state
+      const result = isHydeAvailable()
+      expect(typeof result).toBe('boolean')
+    })
+  })
+
+  describe('HydeOptions interface', () => {
+    it('should accept all configuration options', () => {
+      const options: HydeOptions = {
+        apiKey: 'test-key',
+        model: 'gpt-4o-mini',
+        maxTokens: 256,
+        temperature: 0.3,
+        systemPrompt: 'Custom prompt',
+        baseURL: 'http://localhost:1234/v1',
+      }
+
+      expect(options.apiKey).toBe('test-key')
+      expect(options.model).toBe('gpt-4o-mini')
+      expect(options.maxTokens).toBe(256)
+      expect(options.temperature).toBe(0.3)
+      expect(options.systemPrompt).toBe('Custom prompt')
+      expect(options.baseURL).toBe('http://localhost:1234/v1')
+    })
+
+    it('should allow partial options', () => {
+      const options: HydeOptions = {
+        model: 'gpt-4o',
+      }
+      expect(options.model).toBe('gpt-4o')
+      expect(options.apiKey).toBeUndefined()
+    })
+
+    it('should allow empty options', () => {
+      const options: HydeOptions = {}
+      expect(options).toEqual({})
+    })
+  })
+
+  describe('HydeResult interface', () => {
+    it('should have required fields', () => {
+      const result: HydeResult = {
+        hypotheticalDocument: 'Generated content about authentication...',
+        originalQuery: 'How do I configure authentication?',
+        model: 'gpt-4o-mini',
+        tokensUsed: 150,
+        cost: 0.00003,
+      }
+
+      expect(result.hypotheticalDocument).toBeDefined()
+      expect(result.originalQuery).toBeDefined()
+      expect(result.model).toBeDefined()
+      expect(result.tokensUsed).toBeDefined()
+      expect(result.cost).toBeDefined()
+    })
+  })
+
+  describe('SemanticSearchOptions hyde integration', () => {
+    it('should accept hyde option in SemanticSearchOptions', () => {
+      const options: SemanticSearchOptions = {
+        hyde: true,
+      }
+      expect(options.hyde).toBe(true)
+    })
+
+    it('should default to undefined (HyDE disabled)', () => {
+      const options: SemanticSearchOptions = {}
+      expect(options.hyde).toBeUndefined()
+    })
+
+    it('should accept hydeOptions when hyde is enabled', () => {
+      const options: SemanticSearchOptions = {
+        hyde: true,
+        hydeOptions: {
+          model: 'gpt-4o',
+          maxTokens: 512,
+          temperature: 0.5,
+        },
+      }
+      expect(options.hyde).toBe(true)
+      expect(options.hydeOptions?.model).toBe('gpt-4o')
+      expect(options.hydeOptions?.maxTokens).toBe(512)
+      expect(options.hydeOptions?.temperature).toBe(0.5)
+    })
+
+    it('should accept hyde with other search options', () => {
+      const options: SemanticSearchOptions = {
+        limit: 10,
+        threshold: 0.35,
+        quality: 'thorough',
+        hyde: true,
+        hydeOptions: {
+          model: 'gpt-4o-mini',
+        },
+      }
+      expect(options.limit).toBe(10)
+      expect(options.threshold).toBe(0.35)
+      expect(options.quality).toBe('thorough')
+      expect(options.hyde).toBe(true)
+    })
+  })
+
+  describe('generateHypotheticalDocument error handling', () => {
+    it('should fail with ApiKeyMissingError when no API key', async () => {
+      // Save and clear the environment variable
+      const originalKey = process.env.OPENAI_API_KEY
+      delete process.env.OPENAI_API_KEY
+
+      try {
+        const result = await Effect.runPromise(
+          generateHypotheticalDocument('test query').pipe(Effect.either),
+        )
+
+        expect(result._tag).toBe('Left')
+        if (result._tag === 'Left') {
+          expect(result.left._tag).toBe('ApiKeyMissingError')
+        }
+      } finally {
+        // Restore the environment variable
+        if (originalKey) {
+          process.env.OPENAI_API_KEY = originalKey
+        }
+      }
+    })
+  })
+
+  describe('Query pattern detection', () => {
+    describe('question patterns', () => {
+      it('should detect "how" questions', () => {
+        expect(shouldUseHyde('how to implement feature X')).toBe(true)
+        expect(shouldUseHyde('how does the build system work')).toBe(true)
+      })
+
+      it('should detect "what" questions', () => {
+        expect(shouldUseHyde('what is the recommended approach')).toBe(true)
+        expect(shouldUseHyde('what are the configuration options')).toBe(true)
+      })
+
+      it('should detect "can/could/should" questions', () => {
+        expect(shouldUseHyde('can I use custom validators here')).toBe(true)
+        expect(shouldUseHyde('should I enable caching for this')).toBe(true)
+      })
+
+      it('should detect "is/are/does/do" questions', () => {
+        expect(shouldUseHyde('is there a way to override this')).toBe(true)
+        expect(shouldUseHyde('are there any known issues with')).toBe(true)
+        expect(shouldUseHyde('does the API support pagination')).toBe(true)
+      })
+    })
+
+    describe('procedural patterns', () => {
+      it('should detect setup/install queries', () => {
+        expect(shouldUseHyde('setup local development environment')).toBe(true)
+        expect(shouldUseHyde('install required dependencies for testing')).toBe(
+          true,
+        )
+      })
+
+      it('should detect configure/implement queries', () => {
+        expect(shouldUseHyde('configure database connection pooling')).toBe(
+          true,
+        )
+        expect(shouldUseHyde('implement user session management')).toBe(true)
+      })
+
+      it('should detect fix/debug/resolve queries', () => {
+        expect(shouldUseHyde('fix the authentication issue with tokens')).toBe(
+          true,
+        )
+        expect(shouldUseHyde('debug memory leak in the application')).toBe(true)
+        expect(shouldUseHyde('resolve dependency conflicts in package')).toBe(
+          true,
+        )
+      })
+
+      it('should detect guide/tutorial/example queries', () => {
+        expect(shouldUseHyde('guide for setting up CI CD')).toBe(true)
+        expect(shouldUseHyde('tutorial for building REST APIs')).toBe(true)
+        expect(shouldUseHyde('example of using custom hooks')).toBe(true)
+      })
+    })
+  })
+})
+
+describe('Export verification', () => {
+  it('should export HyDE functions from types module', async () => {
+    const { generateHypotheticalDocument, isHydeAvailable, shouldUseHyde } =
+      await import('./hyde.js')
+    expect(generateHypotheticalDocument).toBeDefined()
+    expect(typeof generateHypotheticalDocument).toBe('function')
+    expect(isHydeAvailable).toBeDefined()
+    expect(typeof isHydeAvailable).toBe('function')
+    expect(shouldUseHyde).toBeDefined()
+    expect(typeof shouldUseHyde).toBe('function')
+  })
+
+  it('should export HyDE functions from main embeddings module', async () => {
+    const { generateHypotheticalDocument, isHydeAvailable, shouldUseHyde } =
+      await import('./index.js')
+    expect(generateHypotheticalDocument).toBeDefined()
+    expect(isHydeAvailable).toBeDefined()
+    expect(shouldUseHyde).toBeDefined()
+  })
+})