mdcontext 0.1.0 → 0.2.0

package/src/cli/utils.ts

@@ -6,6 +6,9 @@
 
 import * as fsPromises from 'node:fs/promises'
 import * as path from 'node:path'
+import { Effect } from 'effect'
+import { listNamespaces } from '../embeddings/embedding-namespace.js'
+import { DirectoryWalkError } from '../errors/index.js'
 
 /**
  * Format object as JSON string
@@ -22,7 +25,8 @@ export const isMarkdownFile = (filename: string): boolean => {
 }
 
 /**
- * Recursively walk directory and collect markdown files
+ * Recursively walk directory and collect markdown files (async version).
+ * @deprecated Use walkDirEffect for typed error handling
  */
 export const walkDir = async (dir: string): Promise<string[]> => {
   const files: string[] = []
@@ -47,6 +51,49 @@ export const walkDir = async (dir: string): Promise<string[]> => {
   return files
 }
 
+/**
+ * Recursively walk directory and collect markdown files.
+ *
+ * @param dir - Directory to walk
+ * @returns List of markdown file paths
+ *
+ * @throws DirectoryWalkError - Cannot read or traverse directory
+ */
+export const walkDirEffect = (
+  dir: string,
+): Effect.Effect<readonly string[], DirectoryWalkError> =>
+  Effect.gen(function* () {
+    const files: string[] = []
+
+    const entries = yield* Effect.tryPromise({
+      try: () => fsPromises.readdir(dir, { withFileTypes: true }),
+      catch: (e) =>
+        new DirectoryWalkError({
+          path: dir,
+          message: `Cannot read directory: ${e instanceof Error ? e.message : String(e)}`,
+          cause: e,
+        }),
+    })
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name)
+
+      // Skip hidden directories and node_modules
+      if (entry.name.startsWith('.') || entry.name === 'node_modules') {
+        continue
+      }
+
+      if (entry.isDirectory()) {
+        const subFiles = yield* walkDirEffect(fullPath)
+        files.push(...subFiles)
+      } else if (entry.isFile() && isMarkdownFile(entry.name)) {
+        files.push(fullPath)
+      }
+    }
+
+    return files
+  })
+
 /**
  * Check if a query looks like a regex pattern
  */
@@ -56,18 +103,66 @@ export const isRegexPattern = (query: string): boolean => {
 }
 
 /**
- * Check if embeddings exist for a directory
+ * Check if embeddings exist for a directory.
+ * Checks for namespaced embeddings in .mdcontext/embeddings/<namespace>/vectors.bin
  */
 export const hasEmbeddings = async (dir: string): Promise<boolean> => {
-  const vectorsPath = path.join(dir, '.mdcontext', 'vectors.bin')
   try {
-    await fsPromises.access(vectorsPath)
-    return true
+    const namespaces = await Effect.runPromise(
+      listNamespaces(dir).pipe(Effect.catchAll(() => Effect.succeed([]))),
+    )
+    return namespaces.length > 0
   } catch {
     return false
   }
 }
 
+/**
+ * Find the nearest parent directory containing an mdcontext index.
+ * Searches from the specified directory up to the filesystem root.
+ *
+ * @param startDir - Directory to start searching from
+ * @returns The directory containing the index, or null if not found
+ */
+export const findIndexRoot = async (
+  startDir: string,
+): Promise<string | null> => {
+  let currentDir = path.resolve(startDir)
+  const root = path.parse(currentDir).root
+
+  while (currentDir !== root) {
+    const sectionsPath = path.join(
+      currentDir,
+      '.mdcontext',
+      'indexes',
+      'sections.json',
+    )
+    try {
+      await fsPromises.access(sectionsPath)
+      return currentDir // Found an index
+    } catch {
+      // No index here, try parent
+      const parent = path.dirname(currentDir)
+      if (parent === currentDir) break // Reached root
+      currentDir = parent
+    }
+  }
+
+  // Also check root
+  const rootSectionsPath = path.join(
+    root,
+    '.mdcontext',
+    'indexes',
+    'sections.json',
+  )
+  try {
+    await fsPromises.access(rootSectionsPath)
+    return root
+  } catch {
+    return null
+  }
+}
+
 /**
  * Get index information for display
  */
@@ -77,11 +172,14 @@ export interface IndexInfo {
   sectionCount?: number | undefined
   embeddingsExist: boolean
   vectorCount?: number | undefined
+  /** The actual directory where the index was found (may differ from requested dir) */
+  indexRoot?: string | undefined
 }
 
 export const getIndexInfo = async (dir: string): Promise<IndexInfo> => {
-  const sectionsPath = path.join(dir, '.mdcontext', 'indexes', 'sections.json')
-  const vectorsMetaPath = path.join(dir, '.mdcontext', 'vectors.meta.json')
+  // First try the specified directory
+  let indexRoot = dir
+  let sectionsPath = path.join(dir, '.mdcontext', 'indexes', 'sections.json')
 
   let exists = false
   let lastUpdated: string | undefined
@@ -89,7 +187,7 @@ export const getIndexInfo = async (dir: string): Promise<IndexInfo> => {
   let embeddingsExist = false
   let vectorCount: number | undefined
 
-  // Check sections index
+  // Check sections index in specified directory
   try {
     const stat = await fsPromises.stat(sectionsPath)
     exists = true
@@ -99,18 +197,52 @@ export const getIndexInfo = async (dir: string): Promise<IndexInfo> => {
     const sections = JSON.parse(content)
     sectionCount = Object.keys(sections.sections || {}).length
   } catch {
-    // Index doesn't exist
+    // Index doesn't exist in specified directory, try to find in parent directories
+    const foundRoot = await findIndexRoot(dir)
+    if (foundRoot) {
+      indexRoot = foundRoot
+      sectionsPath = path.join(
+        foundRoot,
+        '.mdcontext',
+        'indexes',
+        'sections.json',
+      )
+
+      try {
+        const stat = await fsPromises.stat(sectionsPath)
+        exists = true
+        lastUpdated = stat.mtime.toISOString()
+
+        const content = await fsPromises.readFile(sectionsPath, 'utf-8')
+        const sections = JSON.parse(content)
+        sectionCount = Object.keys(sections.sections || {}).length
+      } catch {
+        // Still failed
+      }
+    }
   }
 
-  // Check vectors metadata
+  // Check namespaced embeddings
   try {
-    const content = await fsPromises.readFile(vectorsMetaPath, 'utf-8')
-    const meta = JSON.parse(content)
-    embeddingsExist = true
-    vectorCount = Object.keys(meta.entries || {}).length
-    // Use vector meta updatedAt if available
-    if (meta.updatedAt) {
-      lastUpdated = meta.updatedAt
+    const namespaces = await Effect.runPromise(
+      listNamespaces(indexRoot).pipe(Effect.catchAll(() => Effect.succeed([]))),
+    )
+
+    if (namespaces.length > 0) {
+      embeddingsExist = true
+      // Find active namespace or use first one
+      const activeNs = namespaces.find((ns) => ns.isActive) ?? namespaces[0]
+      if (activeNs) {
+        vectorCount = activeNs.vectorCount
+        // Use namespace's updatedAt if more recent
+        if (activeNs.updatedAt) {
+          const nsDate = new Date(activeNs.updatedAt)
+          const currentDate = lastUpdated ? new Date(lastUpdated) : new Date(0)
+          if (nsDate > currentDate) {
+            lastUpdated = activeNs.updatedAt
+          }
+        }
+      }
     }
   } catch {
     // Embeddings don't exist
@@ -122,5 +254,6 @@ export const getIndexInfo = async (dir: string): Promise<IndexInfo> => {
     sectionCount,
     embeddingsExist,
     vectorCount,
+    indexRoot: exists && indexRoot !== dir ? indexRoot : undefined,
   }
 }

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)
+      }
+    })
+  })
+})