mdcontext 0.0.1 → 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/query-parser.test.ts

@@ -0,0 +1,260 @@
+/**
+ * Tests for query parser
+ */
+
+import { describe, expect, it } from 'vitest'
+import {
+  buildHighlightPattern,
+  evaluateQuery,
+  isAdvancedQuery,
+  parseQuery,
+  type QueryNode,
+} from './query-parser.js'
+
+describe('query-parser', () => {
+  describe('parseQuery', () => {
+    it('should parse a single term', () => {
+      const result = parseQuery('auth')
+      expect(result).not.toBeNull()
+      expect(result!.ast).toEqual({ type: 'term', value: 'auth' })
+      expect(result!.terms).toEqual(['auth'])
+    })
+
+    it('should parse a quoted phrase', () => {
+      const result = parseQuery('"context resumption"')
+      expect(result).not.toBeNull()
+      expect(result!.ast).toEqual({
+        type: 'phrase',
+        value: 'context resumption',
+      })
+      expect(result!.phrases).toEqual(['context resumption'])
+    })
+
+    it('should parse AND operator', () => {
+      const result = parseQuery('auth AND criticism')
+      expect(result).not.toBeNull()
+      expect(result!.ast).toEqual({
+        type: 'and',
+        left: { type: 'term', value: 'auth' },
+        right: { type: 'term', value: 'criticism' },
+      })
+    })
+
+    it('should parse OR operator', () => {
+      const result = parseQuery('checkpoint OR gate')
+      expect(result).not.toBeNull()
+      expect(result!.ast).toEqual({
+        type: 'or',
+        left: { type: 'term', value: 'checkpoint' },
+        right: { type: 'term', value: 'gate' },
+      })
+    })
+
+    it('should parse NOT operator', () => {
+      const result = parseQuery('implementation NOT example')
+      expect(result).not.toBeNull()
+      // "implementation NOT example" is parsed as: implementation AND (NOT example)
+      expect(result!.ast).toEqual({
+        type: 'and',
+        left: { type: 'term', value: 'implementation' },
+        right: { type: 'not', operand: { type: 'term', value: 'example' } },
+      })
+    })
+
+    it('should parse grouped expressions', () => {
+      const result = parseQuery('auth AND (error OR bug)')
+      expect(result).not.toBeNull()
+      expect(result!.ast).toEqual({
+        type: 'and',
+        left: { type: 'term', value: 'auth' },
+        right: {
+          type: 'or',
+          left: { type: 'term', value: 'error' },
+          right: { type: 'term', value: 'bug' },
+        },
+      })
+    })
+
+    it('should handle case-insensitive operators', () => {
+      const result1 = parseQuery('auth and criticism')
+      const result2 = parseQuery('auth And criticism')
+      expect(result1!.ast).toEqual(result2!.ast)
+    })
+
+    it('should parse phrase combined with boolean', () => {
+      const result = parseQuery('"context resumption" AND drift')
+      expect(result).not.toBeNull()
+      expect(result!.ast).toEqual({
+        type: 'and',
+        left: { type: 'phrase', value: 'context resumption' },
+        right: { type: 'term', value: 'drift' },
+      })
+    })
+
+    it('should parse implicit AND between terms', () => {
+      const result = parseQuery('auth error')
+      expect(result).not.toBeNull()
+      expect(result!.ast).toEqual({
+        type: 'and',
+        left: { type: 'term', value: 'auth' },
+        right: { type: 'term', value: 'error' },
+      })
+    })
+
+    it('should respect operator precedence (NOT > AND > OR)', () => {
+      // "a OR b AND NOT c" should parse as "a OR (b AND (NOT c))"
+      const result = parseQuery('a OR b AND NOT c')
+      expect(result).not.toBeNull()
+      expect(result!.ast).toEqual({
+        type: 'or',
+        left: { type: 'term', value: 'a' },
+        right: {
+          type: 'and',
+          left: { type: 'term', value: 'b' },
+          right: { type: 'not', operand: { type: 'term', value: 'c' } },
+        },
+      })
+    })
+
+    it('should return null for empty query', () => {
+      expect(parseQuery('')).toBeNull()
+      expect(parseQuery('   ')).toBeNull()
+    })
+  })
+
+  describe('isAdvancedQuery', () => {
+    it('should return false for simple terms', () => {
+      expect(isAdvancedQuery('auth')).toBe(false)
+      expect(isAdvancedQuery('some term')).toBe(false)
+    })
+
+    it('should return true for boolean operators', () => {
+      expect(isAdvancedQuery('auth AND error')).toBe(true)
+      expect(isAdvancedQuery('auth OR error')).toBe(true)
+      expect(isAdvancedQuery('auth NOT error')).toBe(true)
+    })
+
+    it('should return true for phrases', () => {
+      expect(isAdvancedQuery('"exact phrase"')).toBe(true)
+    })
+
+    it('should return true for grouped expressions', () => {
+      expect(isAdvancedQuery('(a OR b)')).toBe(true)
+    })
+  })
+
+  describe('evaluateQuery', () => {
+    const text = 'This is about authentication errors and bug fixes'
+
+    it('should match single term', () => {
+      const ast: QueryNode = { type: 'term', value: 'authentication' }
+      expect(evaluateQuery(ast, text)).toBe(true)
+    })
+
+    it('should not match missing term', () => {
+      const ast: QueryNode = { type: 'term', value: 'security' }
+      expect(evaluateQuery(ast, text)).toBe(false)
+    })
+
+    it('should match phrase', () => {
+      const ast: QueryNode = { type: 'phrase', value: 'authentication errors' }
+      expect(evaluateQuery(ast, text)).toBe(true)
+    })
+
+    it('should not match partial phrase', () => {
+      const ast: QueryNode = { type: 'phrase', value: 'authentication bug' }
+      expect(evaluateQuery(ast, text)).toBe(false)
+    })
+
+    it('should evaluate AND correctly', () => {
+      const ast: QueryNode = {
+        type: 'and',
+        left: { type: 'term', value: 'authentication' },
+        right: { type: 'term', value: 'bug' },
+      }
+      expect(evaluateQuery(ast, text)).toBe(true)
+
+      const ast2: QueryNode = {
+        type: 'and',
+        left: { type: 'term', value: 'authentication' },
+        right: { type: 'term', value: 'security' },
+      }
+      expect(evaluateQuery(ast2, text)).toBe(false)
+    })
+
+    it('should evaluate OR correctly', () => {
+      const ast: QueryNode = {
+        type: 'or',
+        left: { type: 'term', value: 'authentication' },
+        right: { type: 'term', value: 'security' },
+      }
+      expect(evaluateQuery(ast, text)).toBe(true)
+
+      const ast2: QueryNode = {
+        type: 'or',
+        left: { type: 'term', value: 'crypto' },
+        right: { type: 'term', value: 'security' },
+      }
+      expect(evaluateQuery(ast2, text)).toBe(false)
+    })
+
+    it('should evaluate NOT correctly', () => {
+      const ast: QueryNode = {
+        type: 'not',
+        operand: { type: 'term', value: 'security' },
+      }
+      expect(evaluateQuery(ast, text)).toBe(true)
+
+      const ast2: QueryNode = {
+        type: 'not',
+        operand: { type: 'term', value: 'authentication' },
+      }
+      expect(evaluateQuery(ast2, text)).toBe(false)
+    })
+
+    it('should be case-insensitive', () => {
+      const ast: QueryNode = { type: 'term', value: 'AUTHENTICATION' }
+      expect(evaluateQuery(ast, text)).toBe(true)
+    })
+
+    it('should handle complex nested expressions', () => {
+      // (auth AND bug) OR (error AND NOT fixes)
+      const ast: QueryNode = {
+        type: 'or',
+        left: {
+          type: 'and',
+          left: { type: 'term', value: 'auth' },
+          right: { type: 'term', value: 'bug' },
+        },
+        right: {
+          type: 'and',
+          left: { type: 'term', value: 'error' },
+          right: { type: 'not', operand: { type: 'term', value: 'fixes' } },
+        },
+      }
+      expect(evaluateQuery(ast, text)).toBe(true)
+    })
+  })
+
+  describe('buildHighlightPattern', () => {
+    it('should create pattern from terms', () => {
+      const parsed = parseQuery('auth error')!
+      const pattern = buildHighlightPattern(parsed)
+      expect(pattern.test('authentication error')).toBe(true)
+      expect(pattern.test('no match here')).toBe(false)
+    })
+
+    it('should create pattern from phrases', () => {
+      const parsed = parseQuery('"exact phrase"')!
+      const pattern = buildHighlightPattern(parsed)
+      expect(pattern.test('this is the exact phrase here')).toBe(true)
+    })
+
+    it('should escape special regex characters', () => {
+      const parsed = parseQuery('"test.value"')!
+      const pattern = buildHighlightPattern(parsed)
+      expect(pattern.test('has test.value inside')).toBe(true)
+      expect(pattern.test('has testXvalue inside')).toBe(false) // . should not match any char
+    })
+  })
+})