mdcontext 0.1.0 → 0.2.0

package/src/search/path-matcher.test.ts

@@ -0,0 +1,276 @@
+/**
+ * Tests for path-matcher utilities
+ */
+
+import { describe, expect, it } from 'vitest'
+import { matchPath } from './path-matcher.js'
+
+describe('path-matcher', () => {
+  describe('matchPath', () => {
+    describe('basic patterns', () => {
+      it('matches exact paths', () => {
+        expect(matchPath('docs/readme.md', 'docs/readme.md')).toBe(true)
+        expect(matchPath('src/index.ts', 'src/index.ts')).toBe(true)
+      })
+
+      it('does not match different paths', () => {
+        expect(matchPath('docs/readme.md', 'src/readme.md')).toBe(false)
+        expect(matchPath('docs/readme.md', 'docs/other.md')).toBe(false)
+      })
+
+      it('is case-insensitive', () => {
+        expect(matchPath('docs/README.md', 'docs/readme.md')).toBe(true)
+        expect(matchPath('DOCS/readme.md', 'docs/readme.md')).toBe(true)
+        expect(matchPath('docs/readme.MD', 'docs/readme.md')).toBe(true)
+      })
+    })
+
+    describe('asterisk wildcard (*)', () => {
+      it('matches any characters within filename', () => {
+        expect(matchPath('docs/readme.md', 'docs/*.md')).toBe(true)
+        expect(matchPath('docs/guide.md', 'docs/*.md')).toBe(true)
+        expect(matchPath('docs/api-reference.md', 'docs/*.md')).toBe(true)
+      })
+
+      it('matches empty string with asterisk', () => {
+        expect(matchPath('docs/.md', 'docs/*.md')).toBe(true)
+      })
+
+      it('matches patterns at start of path', () => {
+        expect(matchPath('src/index.ts', '*/index.ts')).toBe(true)
+        expect(matchPath('lib/index.ts', '*/index.ts')).toBe(true)
+      })
+
+      it('matches patterns in middle of path', () => {
+        expect(matchPath('src/utils/index.ts', 'src/*/index.ts')).toBe(true)
+        expect(matchPath('src/helpers/index.ts', 'src/*/index.ts')).toBe(true)
+      })
+
+      it('matches multiple wildcards', () => {
+        expect(matchPath('src/utils/test.ts', '*/*/*.ts')).toBe(true)
+        expect(matchPath('a/b/c.ts', '*/*/*.ts')).toBe(true)
+      })
+
+      it('single asterisk does NOT match directory separators', () => {
+        // Standard glob semantics: * matches within a segment only
+        expect(matchPath('file.md', '*.md')).toBe(true)
+        expect(matchPath('dir/file.md', '*.md')).toBe(false) // * doesn't match /
+        expect(matchPath('deeply/nested/path/file.md', '*')).toBe(false)
+        expect(matchPath('a/b/c.ts', '*.ts')).toBe(false)
+      })
+
+      it('does not match nested paths with single asterisk', () => {
+        expect(matchPath('docs/nested/api.md', 'docs/*.md')).toBe(false)
+        expect(matchPath('src/sub/file.ts', 'src/*.ts')).toBe(false)
+      })
+    })
+
+    describe('double asterisk wildcard (**)', () => {
+      it('matches across directory separators', () => {
+        expect(matchPath('deeply/nested/path/file.md', '**')).toBe(true)
+        expect(matchPath('a/b/c.ts', '**.ts')).toBe(true)
+        expect(matchPath('a/b/c.ts', '**/*.ts')).toBe(true)
+      })
+
+      it('matches nested paths recursively', () => {
+        expect(matchPath('docs/nested/api.md', 'docs/**/*.md')).toBe(true)
+        expect(matchPath('docs/deeply/nested/file.md', 'docs/**/*.md')).toBe(
+          true,
+        )
+        expect(matchPath('src/a/b/c/file.ts', 'src/**/*.ts')).toBe(true)
+      })
+
+      it('matches at beginning of pattern', () => {
+        expect(matchPath('any/path/to/file.md', '**/*.md')).toBe(true)
+        // Note: **/*.md requires at least one /; for root files use *.md or **.md
+        expect(matchPath('file.md', '**.md')).toBe(true)
+        expect(matchPath('file.md', '*.md')).toBe(true)
+      })
+    })
+
+    describe('question mark wildcard (?)', () => {
+      it('matches exactly one character', () => {
+        expect(matchPath('file1.md', 'file?.md')).toBe(true)
+        expect(matchPath('fileA.md', 'file?.md')).toBe(true)
+        expect(matchPath('file-.md', 'file?.md')).toBe(true)
+      })
+
+      it('does not match zero characters', () => {
+        expect(matchPath('file.md', 'file?.md')).toBe(false)
+      })
+
+      it('does not match multiple characters', () => {
+        expect(matchPath('file12.md', 'file?.md')).toBe(false)
+        expect(matchPath('fileABC.md', 'file?.md')).toBe(false)
+      })
+
+      it('matches multiple question marks', () => {
+        expect(matchPath('file12.md', 'file??.md')).toBe(true)
+        expect(matchPath('fileAB.md', 'file??.md')).toBe(true)
+        expect(matchPath('file1.md', 'file??.md')).toBe(false)
+      })
+
+      it('can be combined with asterisk', () => {
+        expect(matchPath('v1/readme.md', 'v?/*.md')).toBe(true)
+        expect(matchPath('v2/guide.md', 'v?/*.md')).toBe(true)
+        expect(matchPath('v10/readme.md', 'v?/*.md')).toBe(false)
+      })
+
+      it('does not match directory separators', () => {
+        expect(matchPath('a/b', 'a?b')).toBe(false) // ? should not match /
+      })
+    })
+
+    describe('dot handling', () => {
+      it('treats dot as literal character', () => {
+        expect(matchPath('file.md', 'file.md')).toBe(true)
+        expect(matchPath('fileXmd', 'file.md')).toBe(false)
+      })
+
+      it('escapes dots in patterns correctly', () => {
+        expect(matchPath('src.utils.index.ts', 'src.utils.index.ts')).toBe(true)
+        expect(matchPath('srcXutilsXindexXts', 'src.utils.index.ts')).toBe(
+          false,
+        )
+      })
+
+      it('matches file extensions correctly', () => {
+        expect(matchPath('readme.md', '*.md')).toBe(true)
+        expect(matchPath('readme.markdown', '*.md')).toBe(false)
+        expect(matchPath('readmeXmd', '*.md')).toBe(false)
+      })
+    })
+
+    describe('special regex characters', () => {
+      it('handles paths with special characters', () => {
+        // The path-matcher now escapes all regex special chars
+        expect(matchPath('file.test.md', 'file.test.md')).toBe(true)
+      })
+
+      it('handles patterns with multiple dots', () => {
+        expect(matchPath('package.config.json', '*.config.json')).toBe(true)
+        expect(matchPath('app.module.ts', '*.module.ts')).toBe(true)
+      })
+
+      it('treats parentheses as literal characters', () => {
+        expect(matchPath('file(1).md', 'file(1).md')).toBe(true)
+        expect(matchPath('file1.md', 'file(1).md')).toBe(false)
+      })
+
+      it('treats square brackets as literal characters', () => {
+        expect(matchPath('[ab].md', '[ab].md')).toBe(true)
+        expect(matchPath('a.md', '[ab].md')).toBe(false)
+        expect(matchPath('b.md', '[ab].md')).toBe(false)
+      })
+
+      it('treats plus as literal character', () => {
+        expect(matchPath('C++.md', 'C++.md')).toBe(true)
+        expect(matchPath('C.md', 'C++.md')).toBe(false)
+      })
+
+      it('treats caret as literal character', () => {
+        expect(matchPath('test^2.md', 'test^2.md')).toBe(true)
+        expect(matchPath('test2.md', 'test^2.md')).toBe(false)
+      })
+
+      it('treats dollar sign as literal character', () => {
+        expect(matchPath('price$100.md', 'price$100.md')).toBe(true)
+        expect(matchPath('price100.md', 'price$100.md')).toBe(false)
+      })
+
+      it('treats curly braces as literal characters', () => {
+        expect(matchPath('obj{}.md', 'obj{}.md')).toBe(true)
+        expect(matchPath('obj.md', 'obj{}.md')).toBe(false)
+      })
+
+      it('treats pipe as literal character', () => {
+        expect(matchPath('a|b.md', 'a|b.md')).toBe(true)
+        expect(matchPath('a.md', 'a|b.md')).toBe(false)
+      })
+
+      it('treats backslash as literal character', () => {
+        expect(matchPath('path\\file.md', 'path\\file.md')).toBe(true)
+        expect(matchPath('pathfile.md', 'path\\file.md')).toBe(false)
+      })
+    })
+
+    describe('edge cases', () => {
+      it('matches empty path with empty pattern', () => {
+        expect(matchPath('', '')).toBe(true)
+      })
+
+      it('does not match non-empty path with empty pattern', () => {
+        expect(matchPath('file.md', '')).toBe(false)
+      })
+
+      it('does not match empty path with non-empty pattern', () => {
+        expect(matchPath('', 'file.md')).toBe(false)
+      })
+
+      it('matches only asterisk pattern', () => {
+        expect(matchPath('anything', '*')).toBe(true)
+        expect(matchPath('', '*')).toBe(true)
+        expect(matchPath('a/b/c', '*')).toBe(false) // * doesn't match /
+        expect(matchPath('a/b/c', '**')).toBe(true) // ** matches everything
+      })
+
+      it('matches only question mark pattern', () => {
+        expect(matchPath('a', '?')).toBe(true)
+        expect(matchPath('ab', '?')).toBe(false)
+        expect(matchPath('', '?')).toBe(false)
+      })
+
+      it('handles very long paths', () => {
+        const longPath = `${'a/'.repeat(50)}file.md`
+        const longPattern = `${'a/'.repeat(50)}*.md`
+        expect(matchPath(longPath, longPattern)).toBe(true)
+      })
+
+      it('handles paths with spaces', () => {
+        expect(matchPath('my docs/readme.md', 'my docs/*.md')).toBe(true)
+        expect(matchPath('path with spaces/file.md', '*/file.md')).toBe(true)
+        // Nested requires **
+        expect(matchPath('a/path with spaces/file.md', '*/file.md')).toBe(false)
+        expect(matchPath('a/path with spaces/file.md', '**/file.md')).toBe(true)
+      })
+
+      it('handles unicode characters', () => {
+        expect(matchPath('docs/日本語.md', 'docs/*.md')).toBe(true)
+        expect(matchPath('文档/readme.md', '*/readme.md')).toBe(true)
+        expect(matchPath('a/文档/readme.md', '**/readme.md')).toBe(true)
+      })
+    })
+
+    describe('real-world patterns', () => {
+      it('matches markdown files in docs folder', () => {
+        expect(matchPath('docs/readme.md', 'docs/*.md')).toBe(true)
+        expect(matchPath('docs/api.md', 'docs/*.md')).toBe(true)
+        // * doesn't match /, use ** for nested paths
+        expect(matchPath('docs/nested/api.md', 'docs/*.md')).toBe(false)
+        expect(matchPath('docs/nested/api.md', 'docs/**/*.md')).toBe(true)
+      })
+
+      it('matches typescript files in src', () => {
+        expect(matchPath('src/index.ts', 'src/*.ts')).toBe(true)
+        expect(matchPath('src/utils.ts', 'src/*.ts')).toBe(true)
+        // Nested requires **
+        expect(matchPath('src/nested/index.ts', 'src/*.ts')).toBe(false)
+        expect(matchPath('src/nested/index.ts', 'src/**/*.ts')).toBe(true)
+      })
+
+      it('matches test files', () => {
+        expect(matchPath('test.spec.ts', '*.spec.ts')).toBe(true)
+        expect(matchPath('utils.test.ts', '*.test.ts')).toBe(true)
+        // Nested requires **
+        expect(matchPath('src/utils.test.ts', '*.test.ts')).toBe(false)
+        expect(matchPath('src/utils.test.ts', '**/*.test.ts')).toBe(true)
+      })
+
+      it('matches config files', () => {
+        expect(matchPath('tsconfig.json', '*.json')).toBe(true)
+        expect(matchPath('package.json', 'package.json')).toBe(true)
+        expect(matchPath('.eslintrc.json', '*.json')).toBe(true)
+      })
+    })
+  })
+})

package/src/search/path-matcher.ts

@@ -0,0 +1,33 @@
+/**
+ * Path matching utilities for search filtering.
+ *
+ * Simple glob-like pattern matching for document paths.
+ */
+
+/**
+ * Match a file path against a glob-like pattern.
+ *
+ * Supports:
+ * - `**` matches any characters including directory separators (recursive)
+ * - `*` matches any characters except directory separators (single segment)
+ * - `?` matches exactly one character (not directory separator)
+ * - `.` is treated literally
+ *
+ * @param filePath - The file path to test
+ * @param pattern - The glob pattern (e.g., "docs/*", "src/api/*.md", "src/** /*.ts")
+ * @returns True if the path matches the pattern
+ */
+export const matchPath = (filePath: string, pattern: string): boolean => {
+  // Use a placeholder for ** to avoid it being processed by single * replacement
+  const DOUBLE_STAR_PLACEHOLDER = '__DOUBLE_STAR_MARKER__'
+
+  const regexPattern = pattern
+    .replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape all regex special chars first
+    .replace(/\*\*/g, DOUBLE_STAR_PLACEHOLDER) // Preserve ** before processing *
+    .replace(/\*/g, '[^/]*') // Single * doesn't match slashes
+    .replace(/\?/g, '[^/]') // ? matches any single non-slash char
+    .replace(new RegExp(DOUBLE_STAR_PLACEHOLDER, 'g'), '.*') // ** matches anything
+
+  const regex = new RegExp(`^${regexPattern}$`, 'i')
+  return regex.test(filePath)
+}

package/src/search/searcher.test.ts

@@ -7,7 +7,12 @@ import * as path from 'node:path'
 import { Effect } from 'effect'
 import { afterAll, beforeAll, describe, expect, it } from 'vitest'
 import { buildIndex } from '../index/indexer.js'
-import { formatContextForLLM, getContext, search } from './searcher.js'
+import {
+  formatContextForLLM,
+  getContext,
+  search,
+  searchContent,
+} from './searcher.js'
 
 // Test fixture directory
 const TEST_DIR = path.join(process.cwd(), 'tests', 'fixtures', 'search')
@@ -66,6 +71,22 @@ An overview of the document.
 `,
     )
 
+    // Create test file for fuzzy/stem search
+    await fs.writeFile(
+      path.join(TEST_DIR, 'stem-test.md'),
+      `# Failure Handling
+
+When the application fails, it logs the failure message.
+Failed operations are retried automatically.
+Failing gracefully is important for user experience.
+
+## Configuration
+
+The configration (typo) file is located at config.json.
+Set the configuration options carefully.
+`,
+    )
+
     // Build index
     await runEffect(buildIndex(TEST_DIR, { force: true }))
   })
@@ -179,4 +200,81 @@ An overview of the document.
       expect(formatted).toContain('[code]')
     })
   })
+
+  describe('searchContent() with fuzzy/stem matching', () => {
+    it('should match stemmed variations with --stem flag', async () => {
+      // Search for "fail" should match "fails", "failed", "failing", "failure"
+      const results = await runEffect(
+        searchContent(TEST_DIR, {
+          content: 'fail',
+          stem: true,
+          pathPattern: 'stem-test*',
+        }),
+      )
+      expect(results.length).toBe(1)
+      expect(results[0]?.section.heading).toBe('Failure Handling')
+      // Should have multiple line matches for different word forms
+      expect(results[0]?.matches?.length).toBeGreaterThan(1)
+    })
+
+    it('should match typos with --fuzzy flag', async () => {
+      // Search for "configration" (typo) should match "configuration"
+      const results = await runEffect(
+        searchContent(TEST_DIR, {
+          content: 'configration',
+          fuzzy: true,
+          pathPattern: 'stem-test*',
+        }),
+      )
+      expect(results.length).toBe(1)
+      expect(results[0]?.section.heading).toBe('Configuration')
+      // Should match both the typo line and the correct spelling line
+      expect(results[0]?.matches?.length).toBeGreaterThanOrEqual(1)
+    })
+
+    it('should respect fuzzyDistance option', async () => {
+      // With distance 1, "fail" should NOT match "file" (distance 2)
+      const strictResults = await runEffect(
+        searchContent(TEST_DIR, {
+          content: 'fail',
+          fuzzy: true,
+          fuzzyDistance: 1,
+          pathPattern: 'stem-test*',
+        }),
+      )
+      // With distance 1, only exact or 1-edit matches
+      const matchedWords = strictResults
+        .flatMap((r) => r.matches?.map((m) => m.line) ?? [])
+        .join(' ')
+        .toLowerCase()
+      // "fail" with distance 1 matches "fails" but not "file"
+      expect(matchedWords).toContain('fail')
+    })
+
+    it('should not match without fuzzy/stem flags', async () => {
+      // Exact search for "fail" should NOT match "failure" or "fails"
+      const results = await runEffect(
+        searchContent(TEST_DIR, {
+          content: 'fail',
+          pathPattern: 'stem-test*',
+        }),
+      )
+      // With exact search, "fail" appears as substring in "fails", "failure", "failing", "failed"
+      // so it still matches, but checks the regex-based behavior
+      expect(results.length).toBeGreaterThanOrEqual(1)
+    })
+
+    it('should combine fuzzy and stem matching', async () => {
+      // Both flags together should provide broader matching
+      const results = await runEffect(
+        searchContent(TEST_DIR, {
+          content: 'fail',
+          fuzzy: true,
+          stem: true,
+          pathPattern: 'stem-test*',
+        }),
+      )
+      expect(results.length).toBeGreaterThanOrEqual(1)
+    })
+  })
 })