mdcontext 0.0.1 → 0.1.0

package/src/search/query-parser.ts

@@ -0,0 +1,319 @@
+/**
+ * Query Parser for mdcontext search
+ *
+ * Supports:
+ * - Boolean operators: AND, OR, NOT (case-insensitive)
+ * - Quoted phrases: "exact phrase"
+ * - Grouping: (term1 OR term2) AND term3
+ * - Precedence: NOT > AND > OR
+ */
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export type QueryNode =
+  | { type: 'term'; value: string }
+  | { type: 'phrase'; value: string }
+  | { type: 'and'; left: QueryNode; right: QueryNode }
+  | { type: 'or'; left: QueryNode; right: QueryNode }
+  | { type: 'not'; operand: QueryNode }
+
+export interface ParsedQuery {
+  readonly ast: QueryNode
+  readonly terms: readonly string[]
+  readonly phrases: readonly string[]
+}
+
+// ============================================================================
+// Tokenizer
+// ============================================================================
+
+type TokenType = 'AND' | 'OR' | 'NOT' | 'LPAREN' | 'RPAREN' | 'PHRASE' | 'TERM'
+
+interface Token {
+  type: TokenType
+  value: string
+}
+
+/**
+ * Tokenize query string into tokens
+ */
+const tokenize = (query: string): Token[] => {
+  const tokens: Token[] = []
+  let i = 0
+
+  while (i < query.length) {
+    // Skip whitespace
+    if (/\s/.test(query[i]!)) {
+      i++
+      continue
+    }
+
+    // Quoted phrase
+    if (query[i] === '"') {
+      const start = i + 1
+      i++
+      while (i < query.length && query[i] !== '"') {
+        i++
+      }
+      const value = query.slice(start, i)
+      tokens.push({ type: 'PHRASE', value })
+      i++ // Skip closing quote
+      continue
+    }
+
+    // Parentheses
+    if (query[i] === '(') {
+      tokens.push({ type: 'LPAREN', value: '(' })
+      i++
+      continue
+    }
+    if (query[i] === ')') {
+      tokens.push({ type: 'RPAREN', value: ')' })
+      i++
+      continue
+    }
+
+    // Words (operators or terms)
+    const wordMatch = query.slice(i).match(/^[^\s()"]+/)
+    if (wordMatch) {
+      const word = wordMatch[0]
+      const upperWord = word.toUpperCase()
+
+      if (upperWord === 'AND') {
+        tokens.push({ type: 'AND', value: 'AND' })
+      } else if (upperWord === 'OR') {
+        tokens.push({ type: 'OR', value: 'OR' })
+      } else if (upperWord === 'NOT') {
+        tokens.push({ type: 'NOT', value: 'NOT' })
+      } else {
+        tokens.push({ type: 'TERM', value: word })
+      }
+      i += word.length
+      continue
+    }
+
+    // Unknown character, skip
+    i++
+  }
+
+  return tokens
+}
+
+// ============================================================================
+// Parser (Recursive Descent)
+// ============================================================================
+
+/**
+ * Parser for boolean query expressions.
+ * Grammar:
+ *   expr     -> andExpr (OR andExpr)*
+ *   andExpr  -> notExpr (AND notExpr)*
+ *   notExpr  -> NOT notExpr | primary
+ *   primary  -> TERM | PHRASE | LPAREN expr RPAREN
+ */
+class Parser {
+  private tokens: Token[]
+  private pos: number = 0
+  readonly terms: string[] = []
+  readonly phrases: string[] = []
+
+  constructor(tokens: Token[]) {
+    this.tokens = tokens
+  }
+
+  private current(): Token | undefined {
+    return this.tokens[this.pos]
+  }
+
+  private advance(): Token | undefined {
+    return this.tokens[this.pos++]
+  }
+
+  private match(type: TokenType): boolean {
+    if (this.current()?.type === type) {
+      this.advance()
+      return true
+    }
+    return false
+  }
+
+  parse(): QueryNode | null {
+    if (this.tokens.length === 0) {
+      return null
+    }
+    return this.parseExpr()
+  }
+
+  private parseExpr(): QueryNode {
+    let left = this.parseAndExpr()
+
+    while (this.match('OR')) {
+      const right = this.parseAndExpr()
+      left = { type: 'or', left, right }
+    }
+
+    return left
+  }
+
+  private parseAndExpr(): QueryNode {
+    let left = this.parseNotExpr()
+
+    // Handle implicit AND (terms without explicit AND between them)
+    while (this.match('AND') || this.isImplicitAnd()) {
+      const right = this.parseNotExpr()
+      left = { type: 'and', left, right }
+    }
+
+    return left
+  }
+
+  private isImplicitAnd(): boolean {
+    const tok = this.current()
+    // If next token is a TERM, PHRASE, NOT, or LPAREN, treat as implicit AND
+    return (
+      tok?.type === 'TERM' ||
+      tok?.type === 'PHRASE' ||
+      tok?.type === 'NOT' ||
+      tok?.type === 'LPAREN'
+    )
+  }
+
+  private parseNotExpr(): QueryNode {
+    if (this.match('NOT')) {
+      const operand = this.parseNotExpr()
+      return { type: 'not', operand }
+    }
+    return this.parsePrimary()
+  }
+
+  private parsePrimary(): QueryNode {
+    const tok = this.current()
+
+    if (this.match('LPAREN')) {
+      const expr = this.parseExpr()
+      this.match('RPAREN') // Consume closing paren (ignore if missing)
+      return expr
+    }
+
+    if (tok?.type === 'PHRASE') {
+      this.advance()
+      this.phrases.push(tok.value)
+      return { type: 'phrase', value: tok.value }
+    }
+
+    if (tok?.type === 'TERM') {
+      this.advance()
+      this.terms.push(tok.value)
+      return { type: 'term', value: tok.value }
+    }
+
+    // Unexpected token, return empty term
+    return { type: 'term', value: '' }
+  }
+}
+
+// ============================================================================
+// Public API
+// ============================================================================
+
+/**
+ * Parse a search query into an AST
+ */
+export const parseQuery = (query: string): ParsedQuery | null => {
+  const tokens = tokenize(query)
+  if (tokens.length === 0) {
+    return null
+  }
+
+  const parser = new Parser(tokens)
+  const ast = parser.parse()
+
+  if (!ast) {
+    return null
+  }
+
+  return {
+    ast,
+    terms: parser.terms,
+    phrases: parser.phrases,
+  }
+}
+
+/**
+ * Check if a query contains boolean operators or phrases
+ */
+export const isAdvancedQuery = (query: string): boolean => {
+  const tokens = tokenize(query)
+  return tokens.some(
+    (t) =>
+      t.type === 'AND' ||
+      t.type === 'OR' ||
+      t.type === 'NOT' ||
+      t.type === 'PHRASE' ||
+      t.type === 'LPAREN',
+  )
+}
+
+/**
+ * Evaluate a parsed query against text content
+ * Returns true if the text matches the query
+ */
+export const evaluateQuery = (ast: QueryNode, text: string): boolean => {
+  const lowerText = text.toLowerCase()
+
+  const evaluate = (node: QueryNode): boolean => {
+    switch (node.type) {
+      case 'term': {
+        // Empty term matches anything
+        if (!node.value) return true
+        return lowerText.includes(node.value.toLowerCase())
+      }
+      case 'phrase': {
+        // Phrase must match exactly (case-insensitive)
+        return lowerText.includes(node.value.toLowerCase())
+      }
+      case 'and': {
+        return evaluate(node.left) && evaluate(node.right)
+      }
+      case 'or': {
+        return evaluate(node.left) || evaluate(node.right)
+      }
+      case 'not': {
+        return !evaluate(node.operand)
+      }
+    }
+  }
+
+  return evaluate(ast)
+}
+
+/**
+ * Build a regex pattern from a parsed query for highlighting matches
+ * This creates a pattern that matches any of the terms/phrases
+ */
+export const buildHighlightPattern = (parsed: ParsedQuery): RegExp => {
+  const patterns: string[] = []
+
+  // Escape special regex chars
+  const escapeChars = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+
+  for (const term of parsed.terms) {
+    if (term) {
+      patterns.push(`\\b${escapeChars(term)}\\b`)
+    }
+  }
+
+  for (const phrase of parsed.phrases) {
+    if (phrase) {
+      patterns.push(escapeChars(phrase))
+    }
+  }
+
+  if (patterns.length === 0) {
+    return /.^/ // Match nothing
+  }
+
+  return new RegExp(patterns.join('|'), 'gi')
+}

package/src/search/searcher.test.ts

@@ -0,0 +1,182 @@
+/**
+ * Tests for keyword search
+ */
+
+import * as fs from 'node:fs/promises'
+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'
+
+// Test fixture directory
+const TEST_DIR = path.join(process.cwd(), 'tests', 'fixtures', 'search')
+
+// Helper to run Effect
+const runEffect = <A, E>(effect: Effect.Effect<A, E>) =>
+  Effect.runPromise(effect)
+
+describe('search', () => {
+  beforeAll(async () => {
+    // Create test fixtures
+    await fs.mkdir(TEST_DIR, { recursive: true })
+
+    // Create test markdown files
+    await fs.writeFile(
+      path.join(TEST_DIR, 'doc1.md'),
+      `# Document One
+
+## Introduction
+
+This is the introduction section.
+
+## Code Example
+
+Here's some code:
+
+\`\`\`typescript
+const x = 1;
+\`\`\`
+
+## Summary
+
+A brief summary.
+`,
+    )
+
+    await fs.writeFile(
+      path.join(TEST_DIR, 'doc2.md'),
+      `# Document Two
+
+## Overview
+
+An overview of the document.
+
+## Data Table
+
+| Column A | Column B |
+|----------|----------|
+| Value 1  | Value 2  |
+
+## Tasks
+
+- Task 1
+- Task 2
+- Task 3
+`,
+    )
+
+    // Build index
+    await runEffect(buildIndex(TEST_DIR, { force: true }))
+  })
+
+  afterAll(async () => {
+    // Clean up
+    await fs.rm(TEST_DIR, { recursive: true, force: true })
+  })
+
+  describe('search()', () => {
+    it('should return all sections without filters', async () => {
+      const results = await runEffect(search(TEST_DIR))
+      expect(results.length).toBeGreaterThan(0)
+    })
+
+    it('should filter by heading pattern', async () => {
+      const results = await runEffect(
+        search(TEST_DIR, { heading: 'Introduction|Overview' }),
+      )
+      expect(results.length).toBe(2)
+      expect(results.map((r) => r.section.heading)).toContain('Introduction')
+      expect(results.map((r) => r.section.heading)).toContain('Overview')
+    })
+
+    it('should filter by path pattern', async () => {
+      const results = await runEffect(
+        search(TEST_DIR, { pathPattern: 'doc1*' }),
+      )
+      expect(results.length).toBeGreaterThan(0)
+      for (const result of results) {
+        expect(result.section.documentPath).toMatch(/doc1/)
+      }
+    })
+
+    it('should filter by hasCode', async () => {
+      const results = await runEffect(search(TEST_DIR, { hasCode: true }))
+      expect(results.length).toBeGreaterThan(0)
+      for (const result of results) {
+        expect(result.section.hasCode).toBe(true)
+      }
+    })
+
+    it('should filter by hasTable', async () => {
+      const results = await runEffect(search(TEST_DIR, { hasTable: true }))
+      expect(results.length).toBeGreaterThan(0)
+      for (const result of results) {
+        expect(result.section.hasTable).toBe(true)
+      }
+    })
+
+    it('should filter by hasList', async () => {
+      const results = await runEffect(search(TEST_DIR, { hasList: true }))
+      expect(results.length).toBeGreaterThan(0)
+      for (const result of results) {
+        expect(result.section.hasList).toBe(true)
+      }
+    })
+
+    it('should respect limit', async () => {
+      const results = await runEffect(search(TEST_DIR, { limit: 2 }))
+      expect(results.length).toBe(2)
+    })
+  })
+
+  describe('getContext()', () => {
+    it('should return document context', async () => {
+      const context = await runEffect(
+        getContext(TEST_DIR, path.join(TEST_DIR, 'doc1.md')),
+      )
+      expect(context.title).toBe('Document One')
+      expect(context.sections.length).toBeGreaterThan(0)
+    })
+
+    it('should respect maxTokens', async () => {
+      const fullContext = await runEffect(
+        getContext(TEST_DIR, path.join(TEST_DIR, 'doc1.md')),
+      )
+      // Use a limit that's definitely smaller than the full document
+      const limitTokens = Math.max(10, Math.floor(fullContext.totalTokens / 2))
+      const limitedContext = await runEffect(
+        getContext(TEST_DIR, path.join(TEST_DIR, 'doc1.md'), {
+          maxTokens: limitTokens,
+        }),
+      )
+      expect(limitedContext.includedTokens).toBeLessThanOrEqual(limitTokens)
+      // Only check for reduction if the full context exceeds the limit
+      if (fullContext.totalTokens > limitTokens) {
+        expect(limitedContext.includedTokens).toBeLessThan(
+          fullContext.totalTokens,
+        )
+      }
+    })
+  })
+
+  describe('formatContextForLLM()', () => {
+    it('should format context as readable text', async () => {
+      const context = await runEffect(
+        getContext(TEST_DIR, path.join(TEST_DIR, 'doc1.md')),
+      )
+      const formatted = formatContextForLLM(context)
+      expect(formatted).toContain('# Document One')
+      expect(formatted).toContain('Path: doc1.md')
+      expect(formatted).toContain('tokens')
+    })
+
+    it('should include content metadata markers', async () => {
+      const context = await runEffect(
+        getContext(TEST_DIR, path.join(TEST_DIR, 'doc1.md')),
+      )
+      const formatted = formatContextForLLM(context)
+      expect(formatted).toContain('[code]')
+    })
+  })
+})