mdcontext 0.1.0 → 0.2.0

package/src/cli/commands/stats.ts

@@ -131,6 +131,9 @@ export const statsCommand = Command.make(
         if (embeddingStats.hasEmbeddings) {
           yield* Console.log(`    Vectors:     ${embeddingStats.count}`)
           yield* Console.log(`    Provider:    ${embeddingStats.provider}`)
+          if (embeddingStats.model) {
+            yield* Console.log(`    Model:       ${embeddingStats.model}`)
+          }
           yield* Console.log(`    Dimensions:  ${embeddingStats.dimensions}`)
           yield* Console.log(
             `    Cost:        $${embeddingStats.totalCost.toFixed(6)}`,

package/src/cli/commands/tree.ts

@@ -9,9 +9,10 @@ import * as path from 'node:path'
 import { Args, Command } from '@effect/cli'
 import { Console, Effect } from 'effect'
 import type { MdSection } from '../../core/types.js'
+import { FileReadError, ParseError } from '../../errors/index.js'
 import { parseFile } from '../../parser/parser.js'
 import { jsonOption, prettyOption } from '../options.js'
-import { formatJson, walkDir } from '../utils.js'
+import { formatJson, walkDirEffect } from '../utils.js'
 
 export const treeCommand = Command.make(
   'tree',
@@ -28,12 +29,32 @@ export const treeCommand = Command.make(
       const resolvedPath = path.resolve(pathArg)
 
       // Auto-detect: file or directory
-      const stat = yield* Effect.try(() => fs.statSync(resolvedPath))
+      const stat = yield* Effect.try({
+        try: () => fs.statSync(resolvedPath),
+        catch: (e) =>
+          new FileReadError({
+            path: resolvedPath,
+            message: `Cannot access path: ${e instanceof Error ? e.message : String(e)}`,
+            cause: e,
+          }),
+      })
 
       if (stat.isFile()) {
         // Show document outline
         const result = yield* parseFile(resolvedPath).pipe(
-          Effect.mapError((e) => new Error(`${e._tag}: ${e.message}`)),
+          Effect.mapError((e) =>
+            e._tag === 'ParseError'
+              ? new ParseError({
+                  message: e.message,
+                  path: resolvedPath,
+                  ...(e.line !== undefined && { line: e.line }),
+                  ...(e.column !== undefined && { column: e.column }),
+                })
+              : new FileReadError({
+                  path: e.path,
+                  message: e.message,
+                }),
+          ),
         )
 
         const extractStructure = (
@@ -84,9 +105,9 @@ export const treeCommand = Command.make(
         }
       } else {
         // Show file list
-        const files = yield* Effect.promise(() => walkDir(resolvedPath))
+        const files = yield* walkDirEffect(resolvedPath)
 
-        const tree = files.sort().map((f) => ({
+        const tree = [...files].sort().map((f) => ({
           path: f,
           relativePath: path.relative(resolvedPath, f),
         }))

package/src/cli/config-layer.ts

@@ -0,0 +1,176 @@
+/**
+ * CLI Configuration Layer
+ *
+ * Creates a configuration layer for use in CLI commands.
+ * Loads config with precedence: CLI flags > Environment > Config file > Defaults
+ */
+
+import { Effect, Layer } from 'effect'
+import {
+  type ConfigProviderOptions,
+  ConfigService,
+  ConfigServiceDefault,
+  createConfigProvider,
+  type MdContextConfig,
+} from '../config/index.js'
+
+/**
+ * Create a ConfigService layer from options.
+ *
+ * This loads configuration with the standard precedence chain:
+ * 1. CLI flags (highest priority)
+ * 2. Environment variables (MDCONTEXT_*)
+ * 3. Config file (if found)
+ * 4. Defaults
+ *
+ * @param options - Configuration provider options
+ * @returns A Layer that provides ConfigService
+ */
+export const makeCliConfigLayer = (
+  options: ConfigProviderOptions = {},
+): Effect.Effect<Layer.Layer<ConfigService, never, never>, never, never> =>
+  Effect.gen(function* () {
+    // Create the config provider with precedence chain
+    const providerResult = yield* createConfigProvider(options).pipe(
+      Effect.catchAll(() =>
+        // If config loading fails, use empty provider (defaults will apply)
+        Effect.succeed(null),
+      ),
+    )
+
+    if (!providerResult) {
+      // Fall back to default config if provider creation failed
+      return ConfigServiceDefault
+    }
+
+    // Load the config using the provider
+    const configResult = yield* Effect.gen(function* () {
+      // Import the schema to load config
+      const { MdContextConfig: MdContextConfigSchema } = yield* Effect.promise(
+        async () => import('../config/schema.js'),
+      )
+      return yield* MdContextConfigSchema
+    }).pipe(
+      Effect.withConfigProvider(providerResult),
+      Effect.catchAll(() => Effect.succeed(null)),
+    )
+
+    if (!configResult) {
+      // Fall back to default config if loading failed
+      return ConfigServiceDefault
+    }
+
+    // Create a layer with the loaded config
+    return Layer.succeed(ConfigService, configResult)
+  })
+
+/**
+ * Create the default CLI configuration layer.
+ *
+ * This loads configuration from:
+ * - Environment variables (MDCONTEXT_*)
+ * - Config file (mdcontext.config.ts/json)
+ * - Built-in defaults
+ *
+ * No CLI flags are applied at this level - commands handle their own flag overrides.
+ */
+export const defaultCliConfigLayer: Effect.Effect<
+  Layer.Layer<ConfigService, never, never>,
+  never,
+  never
+> = makeCliConfigLayer({
+  workingDir: process.cwd(),
+})
+
+/**
+ * Synchronously create a default config layer.
+ *
+ * For use in cases where async config loading isn't possible.
+ * Uses only environment variables and defaults.
+ */
+export const defaultCliConfigLayerSync: Layer.Layer<
+  ConfigService,
+  never,
+  never
+> = ConfigServiceDefault
+
+/**
+ * Get config value with CLI flag override.
+ *
+ * Helper function for commands to get a config value, preferring
+ * an explicit CLI flag value if provided.
+ *
+ * @param cliValue - Value from CLI flag (may be undefined)
+ * @param configValue - Value from config
+ * @returns The CLI value if provided, otherwise the config value
+ */
+export const withCliOverride = <T>(
+  cliValue: T | undefined,
+  configValue: T,
+): T => {
+  return cliValue !== undefined ? cliValue : configValue
+}
+
+/**
+ * Extract relevant config sections for a command.
+ */
+export type SearchConfigValues = {
+  defaultLimit: number
+  maxLimit: number
+  minSimilarity: number
+  includeSnippets: boolean
+  snippetLength: number
+}
+
+export type IndexConfigValues = {
+  maxDepth: number
+  excludePatterns: readonly string[]
+  fileExtensions: readonly string[]
+  followSymlinks: boolean
+  indexDir: string
+}
+
+export type OutputConfigValues = {
+  format: 'text' | 'json'
+  color: boolean
+  prettyJson: boolean
+  verbose: boolean
+  debug: boolean
+}
+
+/**
+ * Extract search config from full config.
+ */
+export const getSearchConfig = (
+  config: MdContextConfig,
+): SearchConfigValues => ({
+  defaultLimit: config.search.defaultLimit,
+  maxLimit: config.search.maxLimit,
+  minSimilarity: config.search.minSimilarity,
+  includeSnippets: config.search.includeSnippets,
+  snippetLength: config.search.snippetLength,
+})
+
+/**
+ * Extract index config from full config.
+ */
+export const getIndexConfig = (config: MdContextConfig): IndexConfigValues => ({
+  maxDepth: config.index.maxDepth,
+  excludePatterns: config.index.excludePatterns,
+  fileExtensions: config.index.fileExtensions,
+  followSymlinks: config.index.followSymlinks,
+  indexDir: config.index.indexDir,
+})
+
+/**
+ * Extract output config from full config.
+ */
+export const getOutputConfig = (
+  config: MdContextConfig,
+): OutputConfigValues => ({
+  format: config.output.format,
+  color: config.output.color,
+  prettyJson: config.output.prettyJson,
+  verbose: config.output.verbose,
+  debug: config.output.debug,
+})

package/src/cli/error-handler.test.ts

@@ -0,0 +1,235 @@
+/**
+ * Unit tests for CLI error handler
+ */
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { formatEffectCliError } from './error-handler.js'
+
+describe('formatEffectCliError', () => {
+  let originalArgv: string[]
+
+  beforeEach(() => {
+    originalArgv = process.argv
+  })
+
+  afterEach(() => {
+    process.argv = originalArgv
+  })
+
+  describe('mode validation errors with suggestions', () => {
+    it('suggests "semantic" for "semantics"', () => {
+      process.argv = ['node', 'cli', 'search', '--mode', 'semantics', 'test']
+
+      const error = {
+        _tag: 'ValidationError',
+        error: {
+          _tag: 'Paragraph',
+          value: {
+            _tag: 'Text',
+            value:
+              'Expected one of the following cases: hybrid, semantic, keyword',
+          },
+        },
+      }
+
+      const result = formatEffectCliError(error)
+      expect(result).toContain("Did you mean '--mode semantic'?")
+    })
+
+    it('suggests "keyword" for "keywords"', () => {
+      process.argv = ['node', 'cli', 'search', '--mode', 'keywords', 'test']
+
+      const error = {
+        _tag: 'ValidationError',
+        error: {
+          _tag: 'Paragraph',
+          value: {
+            _tag: 'Text',
+            value:
+              'Expected one of the following cases: hybrid, semantic, keyword',
+          },
+        },
+      }
+
+      const result = formatEffectCliError(error)
+      expect(result).toContain("Did you mean '--mode keyword'?")
+    })
+
+    it('suggests "hybrid" for "hybrit"', () => {
+      process.argv = ['node', 'cli', 'search', '--mode', 'hybrit', 'test']
+
+      const error = {
+        _tag: 'ValidationError',
+        error: {
+          _tag: 'Paragraph',
+          value: {
+            _tag: 'Text',
+            value:
+              'Expected one of the following cases: hybrid, semantic, keyword',
+          },
+        },
+      }
+
+      const result = formatEffectCliError(error)
+      expect(result).toContain("Did you mean '--mode hybrid'?")
+    })
+
+    it('suggests "semantic" for "semant"', () => {
+      process.argv = ['node', 'cli', 'search', '--mode', 'semant', 'test']
+
+      const error = {
+        _tag: 'ValidationError',
+        error: {
+          _tag: 'Paragraph',
+          value: {
+            _tag: 'Text',
+            value:
+              'Expected one of the following cases: hybrid, semantic, keyword',
+          },
+        },
+      }
+
+      const result = formatEffectCliError(error)
+      expect(result).toContain("Did you mean '--mode semantic'?")
+    })
+
+    it('suggests "keyword" for "keywordd"', () => {
+      process.argv = ['node', 'cli', 'search', '--mode', 'keywordd', 'test']
+
+      const error = {
+        _tag: 'ValidationError',
+        error: {
+          _tag: 'Paragraph',
+          value: {
+            _tag: 'Text',
+            value:
+              'Expected one of the following cases: hybrid, semantic, keyword',
+          },
+        },
+      }
+
+      const result = formatEffectCliError(error)
+      expect(result).toContain("Did you mean '--mode keyword'?")
+    })
+
+    it('does not suggest for typos too far off', () => {
+      process.argv = ['node', 'cli', 'search', '--mode', 'xyz', 'test']
+
+      const error = {
+        _tag: 'ValidationError',
+        error: {
+          _tag: 'Paragraph',
+          value: {
+            _tag: 'Text',
+            value:
+              'Expected one of the following cases: hybrid, semantic, keyword',
+          },
+        },
+      }
+
+      const result = formatEffectCliError(error)
+      expect(result).not.toContain('Did you mean')
+    })
+
+    it('handles --mode=value syntax', () => {
+      process.argv = ['node', 'cli', 'search', '--mode=semantics', 'test']
+
+      const error = {
+        _tag: 'ValidationError',
+        error: {
+          _tag: 'Paragraph',
+          value: {
+            _tag: 'Text',
+            value:
+              'Expected one of the following cases: hybrid, semantic, keyword',
+          },
+        },
+      }
+
+      const result = formatEffectCliError(error)
+      expect(result).toContain("Did you mean '--mode semantic'?")
+    })
+
+    it('handles -m short flag', () => {
+      process.argv = ['node', 'cli', 'search', '-m', 'semantics', 'test']
+
+      const error = {
+        _tag: 'ValidationError',
+        error: {
+          _tag: 'Paragraph',
+          value: {
+            _tag: 'Text',
+            value:
+              'Expected one of the following cases: hybrid, semantic, keyword',
+          },
+        },
+      }
+
+      const result = formatEffectCliError(error)
+      expect(result).toContain("Did you mean '--mode semantic'?")
+    })
+
+    it('does not suggest for non-mode validation errors', () => {
+      process.argv = ['node', 'cli', 'search', 'test']
+
+      const error = {
+        _tag: 'ValidationError',
+        error: {
+          _tag: 'Paragraph',
+          value: {
+            _tag: 'Text',
+            value: 'Some other validation error',
+          },
+        },
+      }
+
+      const result = formatEffectCliError(error)
+      expect(result).toBe('Some other validation error')
+      expect(result).not.toContain('Did you mean')
+    })
+  })
+
+  describe('other error types', () => {
+    it('handles MissingValue errors', () => {
+      process.argv = ['node', 'cli', 'search']
+
+      const error = {
+        _tag: 'MissingValue',
+        error: {
+          _tag: 'Paragraph',
+          value: {
+            _tag: 'Text',
+            value: 'Missing required argument',
+          },
+        },
+      }
+
+      const result = formatEffectCliError(error)
+      expect(result).toBe('Missing required argument')
+    })
+
+    it('handles InvalidValue errors', () => {
+      process.argv = ['node', 'cli', 'search']
+
+      const error = {
+        _tag: 'InvalidValue',
+        error: {
+          _tag: 'Paragraph',
+          value: {
+            _tag: 'Text',
+            value: 'Invalid value provided',
+          },
+        },
+      }
+
+      const result = formatEffectCliError(error)
+      expect(result).toBe('Invalid value provided')
+    })
+
+    it('handles unknown error types', () => {
+      const error = { message: 'Unknown error' }
+      const result = formatEffectCliError(error)
+      expect(result).toBe('[object Object]')
+    })
+  })
+})