mdcontext 0.0.1 → 0.2.0

package/src/config/file-provider.test.ts

@@ -0,0 +1,320 @@
+/**
+ * File-based ConfigProvider Unit Tests
+ *
+ * Tests for loading configuration from files and creating ConfigProviders.
+ */
+
+import * as fs from 'node:fs'
+import * as os from 'node:os'
+import * as path from 'node:path'
+import { Effect } from 'effect'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import {
+  CONFIG_FILE_NAMES,
+  createFileConfigProvider,
+  findConfigFile,
+  loadConfigFile,
+  loadConfigFromPath,
+  loadFileConfigProvider,
+} from './file-provider.js'
+import { MdContextConfig } from './schema.js'
+
+describe('File-based ConfigProvider', () => {
+  let tempDir: string
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mdcontext-test-'))
+  })
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  })
+
+  describe('CONFIG_FILE_NAMES', () => {
+    it('should have the expected file names in order of precedence', () => {
+      expect(CONFIG_FILE_NAMES).toEqual([
+        'mdcontext.config.ts',
+        'mdcontext.config.js',
+        'mdcontext.config.mjs',
+        'mdcontext.config.json',
+        '.mdcontextrc',
+        '.mdcontextrc.json',
+      ])
+    })
+  })
+
+  describe('findConfigFile', () => {
+    it('should return null when no config file exists', () => {
+      const result = findConfigFile(tempDir)
+      expect(result).toBeNull()
+    })
+
+    it('should find mdcontext.config.json', () => {
+      const configPath = path.join(tempDir, 'mdcontext.config.json')
+      fs.writeFileSync(configPath, '{}')
+
+      const result = findConfigFile(tempDir)
+      expect(result).not.toBeNull()
+      expect(result?.path).toBe(configPath)
+      expect(result?.format).toBe('json')
+    })
+
+    it('should find .mdcontextrc', () => {
+      const configPath = path.join(tempDir, '.mdcontextrc')
+      fs.writeFileSync(configPath, '{}')
+
+      const result = findConfigFile(tempDir)
+      expect(result).not.toBeNull()
+      expect(result?.path).toBe(configPath)
+      expect(result?.format).toBe('json')
+    })
+
+    it('should find config in parent directory', () => {
+      const subDir = path.join(tempDir, 'subdir')
+      fs.mkdirSync(subDir)
+      const configPath = path.join(tempDir, 'mdcontext.config.json')
+      fs.writeFileSync(configPath, '{}')
+
+      const result = findConfigFile(subDir)
+      expect(result).not.toBeNull()
+      expect(result?.path).toBe(configPath)
+    })
+
+    it('should prefer higher precedence files', () => {
+      // Create both .ts and .json files
+      fs.writeFileSync(
+        path.join(tempDir, 'mdcontext.config.ts'),
+        'export default {}',
+      )
+      fs.writeFileSync(path.join(tempDir, 'mdcontext.config.json'), '{}')
+
+      const result = findConfigFile(tempDir)
+      expect(result).not.toBeNull()
+      expect(result?.path).toBe(path.join(tempDir, 'mdcontext.config.ts'))
+      expect(result?.format).toBe('ts')
+    })
+
+    it('should identify .js format correctly', () => {
+      const configPath = path.join(tempDir, 'mdcontext.config.js')
+      fs.writeFileSync(configPath, 'module.exports = {}')
+
+      const result = findConfigFile(tempDir)
+      expect(result?.format).toBe('js')
+    })
+
+    it('should identify .mjs format correctly', () => {
+      const configPath = path.join(tempDir, 'mdcontext.config.mjs')
+      fs.writeFileSync(configPath, 'export default {}')
+
+      const result = findConfigFile(tempDir)
+      expect(result?.format).toBe('js')
+    })
+  })
+
+  describe('loadConfigFile', () => {
+    it('should return found: false when no config exists', async () => {
+      const result = await Effect.runPromise(loadConfigFile(tempDir))
+      expect(result.found).toBe(false)
+      if (!result.found) {
+        expect(result.searched.length).toBeGreaterThan(0)
+      }
+    })
+
+    it('should load JSON config file', async () => {
+      const config = {
+        index: { maxDepth: 5 },
+        output: { verbose: true },
+      }
+      fs.writeFileSync(
+        path.join(tempDir, 'mdcontext.config.json'),
+        JSON.stringify(config),
+      )
+
+      const result = await Effect.runPromise(loadConfigFile(tempDir))
+      expect(result.found).toBe(true)
+      if (result.found) {
+        expect(result.config).toEqual(config)
+        expect(result.path).toContain('mdcontext.config.json')
+      }
+    })
+
+    it('should load .mdcontextrc file', async () => {
+      const config = { search: { defaultLimit: 20 } }
+      fs.writeFileSync(
+        path.join(tempDir, '.mdcontextrc'),
+        JSON.stringify(config),
+      )
+
+      const result = await Effect.runPromise(loadConfigFile(tempDir))
+      expect(result.found).toBe(true)
+      if (result.found) {
+        expect(result.config).toEqual(config)
+      }
+    })
+
+    it('should fail with ConfigError for invalid JSON', async () => {
+      fs.writeFileSync(
+        path.join(tempDir, 'mdcontext.config.json'),
+        'not valid json',
+      )
+
+      const result = await Effect.runPromiseExit(loadConfigFile(tempDir))
+      expect(result._tag).toBe('Failure')
+      if (result._tag === 'Failure') {
+        const error = result.cause
+        expect(String(error)).toContain('ConfigError')
+      }
+    })
+  })
+
+  describe('loadConfigFromPath', () => {
+    it('should load config from explicit path', async () => {
+      const configPath = path.join(tempDir, 'custom.json')
+      const config = { index: { maxDepth: 15 } }
+      fs.writeFileSync(configPath, JSON.stringify(config))
+
+      const result = await Effect.runPromise(loadConfigFromPath(configPath))
+      expect(result).toEqual(config)
+    })
+
+    it('should fail with ConfigError when file does not exist', async () => {
+      const configPath = path.join(tempDir, 'nonexistent.json')
+
+      const result = await Effect.runPromiseExit(loadConfigFromPath(configPath))
+      expect(result._tag).toBe('Failure')
+      if (result._tag === 'Failure') {
+        const error = String(result.cause)
+        expect(error).toContain('ConfigError')
+        expect(error).toContain('not found')
+      }
+    })
+
+    it('should fail with ConfigError for invalid JSON', async () => {
+      const configPath = path.join(tempDir, 'invalid.json')
+      fs.writeFileSync(configPath, 'invalid json content')
+
+      const result = await Effect.runPromiseExit(loadConfigFromPath(configPath))
+      expect(result._tag).toBe('Failure')
+      if (result._tag === 'Failure') {
+        expect(String(result.cause)).toContain('ConfigError')
+      }
+    })
+  })
+
+  describe('createFileConfigProvider', () => {
+    it('should create a ConfigProvider from partial config', async () => {
+      const config = {
+        index: { maxDepth: 25 },
+        search: { minSimilarity: 0.8 },
+      }
+      const provider = createFileConfigProvider(config)
+
+      const program = Effect.gen(function* () {
+        return yield* MdContextConfig
+      })
+
+      const result = await Effect.runPromise(
+        Effect.withConfigProvider(program, provider),
+      )
+
+      expect(result.index.maxDepth).toBe(25)
+      expect(result.search.minSimilarity).toBe(0.8)
+      // Defaults should be used for unspecified values
+      expect(result.output.format).toBe('text')
+    })
+
+    it('should work with nested config structure', async () => {
+      const config = {
+        embeddings: {
+          model: 'text-embedding-3-large',
+          batchSize: 50,
+        },
+        paths: {
+          cacheDir: '/custom/cache',
+        },
+      }
+      const provider = createFileConfigProvider(config)
+
+      const program = Effect.gen(function* () {
+        return yield* MdContextConfig
+      })
+
+      const result = await Effect.runPromise(
+        Effect.withConfigProvider(program, provider),
+      )
+
+      expect(result.embeddings.model).toBe('text-embedding-3-large')
+      expect(result.embeddings.batchSize).toBe(50)
+      expect(result.paths.cacheDir).toBe('/custom/cache')
+    })
+  })
+
+  describe('loadFileConfigProvider', () => {
+    it('should return empty provider when no config file exists', async () => {
+      const provider = await Effect.runPromise(loadFileConfigProvider(tempDir))
+
+      // Provider should exist but provide no overrides
+      const program = Effect.gen(function* () {
+        return yield* MdContextConfig
+      })
+
+      const result = await Effect.runPromise(
+        Effect.withConfigProvider(program, provider),
+      )
+
+      // All defaults should be used
+      expect(result.index.maxDepth).toBe(10)
+    })
+
+    it('should load config and create provider in one step', async () => {
+      const config = {
+        index: { maxDepth: 30 },
+        output: { debug: true },
+      }
+      fs.writeFileSync(
+        path.join(tempDir, 'mdcontext.config.json'),
+        JSON.stringify(config),
+      )
+
+      const provider = await Effect.runPromise(loadFileConfigProvider(tempDir))
+
+      const program = Effect.gen(function* () {
+        return yield* MdContextConfig
+      })
+
+      const result = await Effect.runPromise(
+        Effect.withConfigProvider(program, provider),
+      )
+
+      expect(result.index.maxDepth).toBe(30)
+      expect(result.output.debug).toBe(true)
+    })
+  })
+
+  describe('JavaScript/TypeScript config loading', () => {
+    it('should load .mjs config with default export', async () => {
+      const configPath = path.join(tempDir, 'mdcontext.config.mjs')
+      fs.writeFileSync(configPath, `export default { index: { maxDepth: 42 } }`)
+
+      const result = await Effect.runPromise(loadConfigFile(tempDir))
+      expect(result.found).toBe(true)
+      if (result.found) {
+        expect(result.config.index?.maxDepth).toBe(42)
+      }
+    })
+
+    it('should load .mjs config with named export', async () => {
+      const configPath = path.join(tempDir, 'mdcontext.config.mjs')
+      fs.writeFileSync(
+        configPath,
+        `export const config = { search: { defaultLimit: 50 } }`,
+      )
+
+      const result = await Effect.runPromise(loadConfigFile(tempDir))
+      expect(result.found).toBe(true)
+      if (result.found) {
+        expect(result.config.search?.defaultLimit).toBe(50)
+      }
+    })
+  })
+})

package/src/config/file-provider.ts

@@ -0,0 +1,273 @@
+/**
+ * File-based ConfigProvider
+ *
+ * Creates a custom ConfigProvider that reads from config files:
+ * - mdcontext.config.ts (TypeScript - dynamic import)
+ * - mdcontext.config.js (JavaScript - dynamic import)
+ * - mdcontext.config.json (JSON - file read)
+ * - .mdcontextrc (JSON - file read)
+ * - .mdcontextrc.json (JSON - file read)
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import { loadConfigFile, createFileConfigProvider } from './config/file-provider.js'
+ * import { Effect, ConfigProvider } from 'effect'
+ *
+ * // Load config and create provider
+ * const result = await loadConfigFile('/path/to/project')
+ * if (result.found) {
+ *   const provider = createFileConfigProvider(result.config)
+ *   // Use with Effect.withConfigProvider
+ * }
+ * ```
+ */
+
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import { ConfigProvider, Effect } from 'effect'
+import { ConfigError } from '../errors/index.js'
+import type { PartialMdContextConfig } from './service.js'
+
+// ============================================================================
+// Types
+// ============================================================================
+
+/**
+ * Supported config file names in order of precedence
+ */
+export const CONFIG_FILE_NAMES = [
+  'mdcontext.config.ts',
+  'mdcontext.config.js',
+  'mdcontext.config.mjs',
+  'mdcontext.config.json',
+  '.mdcontextrc',
+  '.mdcontextrc.json',
+] as const
+
+export type ConfigFileName = (typeof CONFIG_FILE_NAMES)[number]
+
+/**
+ * Result of loading a config file
+ */
+export type LoadConfigResult =
+  | { found: true; path: string; config: PartialMdContextConfig }
+  | { found: false; searched: string[] }
+
+/**
+ * Config file format
+ */
+export type ConfigFileFormat = 'ts' | 'js' | 'json'
+
+// ============================================================================
+// File Detection
+// ============================================================================
+
+/**
+ * Find a config file starting from the given directory.
+ * Searches up the directory tree until a config file is found or root is reached.
+ *
+ * @param startDir - Directory to start searching from
+ * @returns The path to the config file if found, or null
+ */
+export const findConfigFile = (
+  startDir: string,
+): { path: string; format: ConfigFileFormat } | null => {
+  let currentDir = path.resolve(startDir)
+  const root = path.parse(currentDir).root
+
+  while (currentDir !== root) {
+    for (const fileName of CONFIG_FILE_NAMES) {
+      const configPath = path.join(currentDir, fileName)
+      if (fs.existsSync(configPath)) {
+        const format = getConfigFormat(fileName)
+        return { path: configPath, format }
+      }
+    }
+    const parentDir = path.dirname(currentDir)
+    if (parentDir === currentDir) break
+    currentDir = parentDir
+  }
+
+  return null
+}
+
+/**
+ * Get the format of a config file based on its name
+ */
+const getConfigFormat = (fileName: string): ConfigFileFormat => {
+  if (fileName.endsWith('.ts')) return 'ts'
+  if (fileName.endsWith('.js') || fileName.endsWith('.mjs')) return 'js'
+  return 'json'
+}
+
+// ============================================================================
+// File Loading
+// ============================================================================
+
+/**
+ * Load configuration from a JSON file
+ */
+const loadJsonConfig = (
+  filePath: string,
+): Effect.Effect<PartialMdContextConfig, ConfigError> =>
+  Effect.try({
+    try: () => {
+      const content = fs.readFileSync(filePath, 'utf-8')
+      return JSON.parse(content) as PartialMdContextConfig
+    },
+    catch: (error) =>
+      new ConfigError({
+        field: 'configFile',
+        message: `Failed to load config from ${filePath}: ${error instanceof Error ? error.message : String(error)}`,
+        cause: error,
+      }),
+  })
+
+/**
+ * Load configuration from a JavaScript/TypeScript file using dynamic import
+ */
+const loadJsConfig = (
+  filePath: string,
+): Effect.Effect<PartialMdContextConfig, ConfigError> =>
+  Effect.tryPromise({
+    try: async () => {
+      // Convert to file URL for dynamic import
+      const fileUrl = `file://${filePath}`
+      const module = await import(fileUrl)
+      // Support both default export and named 'config' export
+      const config = module.default ?? module.config
+      if (!config || typeof config !== 'object') {
+        throw new Error(
+          'Config file must export a default object or named "config" export',
+        )
+      }
+      return config as PartialMdContextConfig
+    },
+    catch: (error) =>
+      new ConfigError({
+        field: 'configFile',
+        message: `Failed to load config from ${filePath}: ${error instanceof Error ? error.message : String(error)}`,
+        cause: error,
+      }),
+  })
+
+/**
+ * Load configuration from a file based on its format
+ */
+export const loadConfigFromFile = (
+  filePath: string,
+  format: ConfigFileFormat,
+): Effect.Effect<PartialMdContextConfig, ConfigError> => {
+  switch (format) {
+    case 'json':
+      return loadJsonConfig(filePath)
+    case 'ts':
+    case 'js':
+      return loadJsConfig(filePath)
+  }
+}
+
+/**
+ * Search for and load a config file starting from the given directory.
+ *
+ * @param startDir - Directory to start searching from
+ * @returns LoadConfigResult indicating whether a config was found
+ */
+export const loadConfigFile = (
+  startDir: string,
+): Effect.Effect<LoadConfigResult, ConfigError> =>
+  Effect.gen(function* () {
+    const found = findConfigFile(startDir)
+
+    if (!found) {
+      return {
+        found: false,
+        searched: CONFIG_FILE_NAMES.map((name) => path.join(startDir, name)),
+      } as LoadConfigResult
+    }
+
+    const config = yield* loadConfigFromFile(found.path, found.format)
+
+    return {
+      found: true,
+      path: found.path,
+      config,
+    } as LoadConfigResult
+  })
+
+/**
+ * Load a config file from a specific path (not searching up directories)
+ *
+ * @param configPath - Explicit path to the config file
+ * @returns The loaded configuration
+ */
+export const loadConfigFromPath = (
+  configPath: string,
+): Effect.Effect<PartialMdContextConfig, ConfigError> =>
+  Effect.gen(function* () {
+    const resolvedPath = path.resolve(configPath)
+
+    if (!fs.existsSync(resolvedPath)) {
+      return yield* Effect.fail(
+        new ConfigError({
+          field: 'configFile',
+          message: `Config file not found: ${resolvedPath}`,
+        }),
+      )
+    }
+
+    const format = getConfigFormat(path.basename(configPath))
+    return yield* loadConfigFromFile(resolvedPath, format)
+  })
+
+// ============================================================================
+// ConfigProvider Creation
+// ============================================================================
+
+/**
+ * Create a ConfigProvider from a partial configuration object.
+ *
+ * The provider uses ConfigProvider.fromJson to map the nested config
+ * structure to Effect's config namespace.
+ *
+ * @param config - Partial configuration object
+ * @returns A ConfigProvider that provides the config values
+ */
+export const createFileConfigProvider = (
+  config: PartialMdContextConfig,
+): ConfigProvider.ConfigProvider => ConfigProvider.fromJson(config)
+
+/**
+ * Load config file and create a ConfigProvider in one step.
+ *
+ * If no config file is found, returns a ConfigProvider that provides no values
+ * (Effect will use defaults from the Config schema).
+ *
+ * @param startDir - Directory to start searching for config files
+ * @returns Effect yielding a ConfigProvider
+ */
+export const loadFileConfigProvider = (
+  startDir: string,
+): Effect.Effect<ConfigProvider.ConfigProvider, ConfigError> =>
+  Effect.gen(function* () {
+    const result = yield* loadConfigFile(startDir)
+
+    if (!result.found) {
+      // Return empty provider - defaults will be used
+      return ConfigProvider.fromMap(new Map())
+    }
+
+    return createFileConfigProvider(result.config)
+  })
+
+/**
+ * Load config from a specific file and create a ConfigProvider.
+ *
+ * @param configPath - Path to the config file
+ * @returns Effect yielding a ConfigProvider
+ */
+export const loadFileConfigProviderFromPath = (
+  configPath: string,
+): Effect.Effect<ConfigProvider.ConfigProvider, ConfigError> =>
+  Effect.map(loadConfigFromPath(configPath), createFileConfigProvider)

package/src/config/index.ts

@@ -0,0 +1,72 @@
+/**
+ * Configuration Module
+ *
+ * Exports all configuration-related types, schemas, and utilities.
+ */
+
+export {
+  // File detection
+  CONFIG_FILE_NAMES,
+  type ConfigFileFormat,
+  type ConfigFileName,
+  // Provider creation
+  createFileConfigProvider,
+  findConfigFile,
+  type LoadConfigResult,
+  // File loading
+  loadConfigFile,
+  loadConfigFromPath,
+  loadFileConfigProvider,
+  loadFileConfigProviderFromPath,
+} from './file-provider.js'
+export {
+  // Precedence chain
+  type ConfigProviderOptions,
+  createCliConfigProvider,
+  createConfigProvider,
+  createConfigProviderSync,
+  createEnvConfigProvider,
+  createTestConfigProvider,
+  // Utilities
+  flattenConfig,
+  readEnvConfig,
+} from './precedence.js'
+export {
+  // Default values
+  defaultConfig,
+  // Types
+  type EmbeddingProvider,
+  EmbeddingsConfig,
+  // Config schemas
+  IndexConfig,
+  MdContextConfig,
+  type OpenAIEmbeddingModel,
+  OutputConfig,
+  type OutputFormat,
+  PathsConfig,
+  SearchConfig,
+  SummarizationConfig,
+} from './schema.js'
+export {
+  // Service
+  ConfigService,
+  ConfigServiceDefault,
+  ConfigServiceLive,
+  // Helper functions
+  getConfig,
+  getConfigSection,
+  getConfigValue,
+  // Layer utilities
+  makeConfigLayer,
+  makeConfigLayerPartial,
+  // Merge utilities
+  mergeWithDefaults,
+  type PartialMdContextConfig,
+} from './service.js'
+export {
+  // Testing utilities
+  runWithConfig,
+  runWithConfigSync,
+  TestConfigLayer,
+  withTestConfig,
+} from './testing.js'