claude-brain 0.14.0 → 0.14.2

package/src/vault/query.ts

@@ -1,422 +1,422 @@
-/**
- * Vault Query Engine
- * Powerful search and query capabilities across the entire vault
- */
-
-import path from 'path'
-import type { Logger } from 'pino'
-import type { MarkdownFile } from './types'
-import { VaultReader } from './reader'
-import { FrontmatterUtils } from './frontmatter'
-
-export interface QueryOptions {
-  text?: string // Full-text search
-  tags?: string[] // Filter by tags
-  status?: string // Filter by status
-  project?: string // Filter by project
-  type?: string // Filter by document type
-  dateRange?: {
-    // Filter by date range
-    start?: Date
-    end?: Date
-    field?: string // Which date field to use (default: 'updated')
-  }
-  techStack?: string[] // Filter by tech stack
-  limit?: number // Max results
-  offset?: number // Skip first N results
-  sortBy?: 'score' | 'date' | 'name' // Sort order
-  sortDirection?: 'asc' | 'desc'
-}
-
-export interface QueryResult {
-  file: MarkdownFile
-  score: number // Relevance score
-  matches: string[] // Matched terms
-}
-
-export interface QueryStats {
-  totalFiles: number
-  matchedFiles: number
-  executionTimeMs: number
-}
-
-export class VaultQuery {
-  private reader: VaultReader
-  private logger: Logger
-
-  constructor(reader: VaultReader, logger: Logger) {
-    this.reader = reader
-    this.logger = logger.child({ component: 'vault-query' })
-  }
-
-  /**
-   * Query vault with multiple filters
-   */
-  async query(
-    vaultPath: string,
-    options: QueryOptions
-  ): Promise<{ results: QueryResult[]; stats: QueryStats }> {
-    const startTime = Date.now()
-
-    try {
-      // Get all markdown files
-      const projectsPath = path.join(vaultPath, 'Projects')
-      const globalPath = path.join(vaultPath, 'Global')
-
-      // Read from both Projects and Global directories
-      const projectFiles = await this.reader.readDirectory(projectsPath, true)
-      const globalFiles = await this.reader.readDirectory(globalPath, true)
-      const allFiles = [...projectFiles, ...globalFiles]
-
-      // Read all files
-      const markdownFiles = await Promise.all(
-        allFiles.map(f =>
-          this.reader.readMarkdownFile(f).catch(() => null)
-        )
-      )
-
-      // Filter out failed reads
-      const validFiles = markdownFiles.filter(
-        (f): f is MarkdownFile => f !== null
-      )
-
-      // Filter and score
-      let results = validFiles
-        .map(file => this.scoreFile(file, options))
-        .filter(result => result.score > 0)
-
-      // Sort results
-      results = this.sortResults(results, options)
-
-      // Apply offset and limit
-      if (options.offset) {
-        results = results.slice(options.offset)
-      }
-      if (options.limit) {
-        results = results.slice(0, options.limit)
-      }
-
-      const stats: QueryStats = {
-        totalFiles: allFiles.length,
-        matchedFiles: results.length,
-        executionTimeMs: Date.now() - startTime
-      }
-
-      this.logger.debug(
-        { options, stats },
-        'Query executed'
-      )
-
-      return { results, stats }
-    } catch (error) {
-      this.logger.error({ error, options }, 'Query failed')
-      return {
-        results: [],
-        stats: {
-          totalFiles: 0,
-          matchedFiles: 0,
-          executionTimeMs: Date.now() - startTime
-        }
-      }
-    }
-  }
-
-  /**
-   * Score a file against query options
-   */
-  private scoreFile(file: MarkdownFile, options: QueryOptions): QueryResult {
-    let score = 0
-    const matches: string[] = []
-
-    // Text search
-    if (options.text) {
-      const textScore = this.scoreTextMatch(file, options.text)
-      score += textScore.score
-      matches.push(...textScore.matches)
-    }
-
-    // Tag filter
-    if (options.tags && options.tags.length > 0) {
-      const fileTags = FrontmatterUtils.getTags(file.frontmatter)
-      const matchedTags = options.tags.filter(tag =>
-        fileTags.some(ft => ft.toLowerCase() === tag.toLowerCase())
-      )
-
-      if (matchedTags.length > 0) {
-        score += matchedTags.length * 20
-        matches.push(...matchedTags.map(t => `tag:${t}`))
-      } else {
-        // No tag match means exclude this file
-        return { file, score: 0, matches: [] }
-      }
-    }
-
-    // Status filter
-    if (options.status) {
-      const fileStatus = FrontmatterUtils.getStatus(file.frontmatter)
-      if (fileStatus?.toLowerCase() === options.status.toLowerCase()) {
-        score += 15
-        matches.push(`status:${options.status}`)
-      } else {
-        return { file, score: 0, matches: [] }
-      }
-    }
-
-    // Project filter
-    if (options.project) {
-      const fileProject = FrontmatterUtils.getProject(file.frontmatter)
-      if (fileProject?.toLowerCase() === options.project.toLowerCase()) {
-        score += 25
-        matches.push(`project:${options.project}`)
-      } else {
-        return { file, score: 0, matches: [] }
-      }
-    }
-
-    // Type filter
-    if (options.type) {
-      const fileType = FrontmatterUtils.getType(file.frontmatter)
-      if (fileType?.toLowerCase() === options.type.toLowerCase()) {
-        score += 15
-        matches.push(`type:${options.type}`)
-      } else {
-        return { file, score: 0, matches: [] }
-      }
-    }
-
-    // Tech stack filter
-    if (options.techStack && options.techStack.length > 0) {
-      const fileTechStack = FrontmatterUtils.getTechStack(file.frontmatter)
-      const matchedTech = options.techStack.filter(tech =>
-        fileTechStack.some(ft => ft.toLowerCase() === tech.toLowerCase())
-      )
-
-      if (matchedTech.length > 0) {
-        score += matchedTech.length * 15
-        matches.push(...matchedTech.map(t => `tech:${t}`))
-      } else {
-        return { file, score: 0, matches: [] }
-      }
-    }
-
-    // Date range filter
-    if (options.dateRange) {
-      const dateField = options.dateRange.field || 'updated'
-      const fileDate = FrontmatterUtils.getDate(file.frontmatter, dateField)
-
-      if (fileDate) {
-        const { start, end } = options.dateRange
-
-        if (start && fileDate < start) {
-          return { file, score: 0, matches: [] }
-        }
-        if (end && fileDate > end) {
-          return { file, score: 0, matches: [] }
-        }
-
-        score += 5
-      } else if (options.dateRange.start || options.dateRange.end) {
-        // If date range is specified but file has no date, exclude it
-        return { file, score: 0, matches: [] }
-      }
-    }
-
-    // Boost score if no specific filters but file was matched
-    if (score === 0 && !options.text) {
-      // If no filters applied, give base score
-      score = 1
-    }
-
-    return { file, score, matches }
-  }
-
-  /**
-   * Score text match with term highlighting
-   */
-  private scoreTextMatch(
-    file: MarkdownFile,
-    searchText: string
-  ): { score: number; matches: string[] } {
-    const searchTerms = searchText.toLowerCase().split(/\s+/).filter(Boolean)
-    const content = file.content.toLowerCase()
-    const title = path.basename(file.path, '.md').toLowerCase()
-    const frontmatterText = JSON.stringify(file.frontmatter).toLowerCase()
-
-    let score = 0
-    const matches: string[] = []
-
-    for (const term of searchTerms) {
-      // Check title (highest weight)
-      if (title.includes(term)) {
-        score += 30
-        matches.push(`title:${term}`)
-      }
-
-      // Check frontmatter (medium weight)
-      if (frontmatterText.includes(term)) {
-        score += 15
-        if (!matches.includes(`title:${term}`)) {
-          matches.push(`frontmatter:${term}`)
-        }
-      }
-
-      // Check content (base weight)
-      if (content.includes(term)) {
-        // Count occurrences for scoring
-        const occurrences = (content.match(new RegExp(term, 'gi')) || []).length
-        score += Math.min(occurrences * 2, 20) // Cap at 20 points per term
-        if (!matches.some(m => m.includes(term))) {
-          matches.push(term)
-        }
-      }
-    }
-
-    return { score, matches }
-  }
-
-  /**
-   * Sort results based on options
-   */
-  private sortResults(
-    results: QueryResult[],
-    options: QueryOptions
-  ): QueryResult[] {
-    const sortBy = options.sortBy || 'score'
-    const direction = options.sortDirection || 'desc'
-    const multiplier = direction === 'desc' ? -1 : 1
-
-    return results.sort((a, b) => {
-      switch (sortBy) {
-        case 'score':
-          return (a.score - b.score) * multiplier
-
-        case 'date': {
-          const dateA = FrontmatterUtils.getDate(a.file.frontmatter)
-          const dateB = FrontmatterUtils.getDate(b.file.frontmatter)
-          if (!dateA && !dateB) return 0
-          if (!dateA) return 1
-          if (!dateB) return -1
-          return (dateA.getTime() - dateB.getTime()) * multiplier
-        }
-
-        case 'name': {
-          const nameA = path.basename(a.file.path)
-          const nameB = path.basename(b.file.path)
-          return nameA.localeCompare(nameB) * multiplier
-        }
-
-        default:
-          return (a.score - b.score) * multiplier
-      }
-    })
-  }
-
-  /**
-   * Search by text only (simplified)
-   */
-  async searchText(
-    vaultPath: string,
-    searchText: string,
-    limit: number = 10
-  ): Promise<QueryResult[]> {
-    const { results } = await this.query(vaultPath, { text: searchText, limit })
-    return results
-  }
-
-  /**
-   * Get files by tag
-   */
-  async getByTag(vaultPath: string, tag: string): Promise<QueryResult[]> {
-    const { results } = await this.query(vaultPath, { tags: [tag] })
-    return results
-  }
-
-  /**
-   * Get files by project
-   */
-  async getByProject(
-    vaultPath: string,
-    project: string
-  ): Promise<QueryResult[]> {
-    const { results } = await this.query(vaultPath, { project })
-    return results
-  }
-
-  /**
-   * Get files by document type
-   */
-  async getByType(vaultPath: string, type: string): Promise<QueryResult[]> {
-    const { results } = await this.query(vaultPath, { type })
-    return results
-  }
-
-  /**
-   * Get recently updated files
-   */
-  async getRecentlyUpdated(
-    vaultPath: string,
-    days: number = 7,
-    limit: number = 10
-  ): Promise<QueryResult[]> {
-    const start = new Date()
-    start.setDate(start.getDate() - days)
-
-    const { results } = await this.query(vaultPath, {
-      dateRange: { start },
-      sortBy: 'date',
-      sortDirection: 'desc',
-      limit
-    })
-
-    return results
-  }
-
-  /**
-   * Get all projects with their metadata
-   */
-  async getAllProjects(vaultPath: string): Promise<
-    Array<{
-      name: string
-      status: string
-      contextFile: MarkdownFile | null
-    }>
-  > {
-    const projectsPath = path.join(vaultPath, 'Projects')
-    const projectDirs = await this.reader.getProjectDirectories(projectsPath)
-
-    const projects = await Promise.all(
-      projectDirs.map(async name => {
-        const contextPath = path.join(projectsPath, name, 'context.md')
-        let contextFile: MarkdownFile | null = null
-
-        try {
-          contextFile = await this.reader.readMarkdownFile(contextPath)
-        } catch {
-          // Context file might not exist
-        }
-
-        return {
-          name,
-          status: contextFile
-            ? FrontmatterUtils.getStatus(contextFile.frontmatter) || 'unknown'
-            : 'unknown',
-          contextFile
-        }
-      })
-    )
-
-    return projects
-  }
-
-  /**
-   * Get project files
-   */
-  async getProjectFiles(
-    vaultPath: string,
-    projectName: string
-  ): Promise<MarkdownFile[]> {
-    const projectPath = path.join(vaultPath, 'Projects', projectName)
-    const files = await this.reader.readDirectory(projectPath, false)
-    return this.reader.readMarkdownFiles(files)
-  }
-}
+/**
+ * Vault Query Engine
+ * Powerful search and query capabilities across the entire vault
+ */
+
+import path from 'path'
+import type { Logger } from 'pino'
+import type { MarkdownFile } from './types'
+import { VaultReader } from './reader'
+import { FrontmatterUtils } from './frontmatter'
+
+export interface QueryOptions {
+  text?: string // Full-text search
+  tags?: string[] // Filter by tags
+  status?: string // Filter by status
+  project?: string // Filter by project
+  type?: string // Filter by document type
+  dateRange?: {
+    // Filter by date range
+    start?: Date
+    end?: Date
+    field?: string // Which date field to use (default: 'updated')
+  }
+  techStack?: string[] // Filter by tech stack
+  limit?: number // Max results
+  offset?: number // Skip first N results
+  sortBy?: 'score' | 'date' | 'name' // Sort order
+  sortDirection?: 'asc' | 'desc'
+}
+
+export interface QueryResult {
+  file: MarkdownFile
+  score: number // Relevance score
+  matches: string[] // Matched terms
+}
+
+export interface QueryStats {
+  totalFiles: number
+  matchedFiles: number
+  executionTimeMs: number
+}
+
+export class VaultQuery {
+  private reader: VaultReader
+  private logger: Logger
+
+  constructor(reader: VaultReader, logger: Logger) {
+    this.reader = reader
+    this.logger = logger.child({ component: 'vault-query' })
+  }
+
+  /**
+   * Query vault with multiple filters
+   */
+  async query(
+    vaultPath: string,
+    options: QueryOptions
+  ): Promise<{ results: QueryResult[]; stats: QueryStats }> {
+    const startTime = Date.now()
+
+    try {
+      // Get all markdown files
+      const projectsPath = path.join(vaultPath, 'Projects')
+      const globalPath = path.join(vaultPath, 'Global')
+
+      // Read from both Projects and Global directories
+      const projectFiles = await this.reader.readDirectory(projectsPath, true)
+      const globalFiles = await this.reader.readDirectory(globalPath, true)
+      const allFiles = [...projectFiles, ...globalFiles]
+
+      // Read all files
+      const markdownFiles = await Promise.all(
+        allFiles.map(f =>
+          this.reader.readMarkdownFile(f).catch(() => null)
+        )
+      )
+
+      // Filter out failed reads
+      const validFiles = markdownFiles.filter(
+        (f): f is MarkdownFile => f !== null
+      )
+
+      // Filter and score
+      let results = validFiles
+        .map(file => this.scoreFile(file, options))
+        .filter(result => result.score > 0)
+
+      // Sort results
+      results = this.sortResults(results, options)
+
+      // Apply offset and limit
+      if (options.offset) {
+        results = results.slice(options.offset)
+      }
+      if (options.limit) {
+        results = results.slice(0, options.limit)
+      }
+
+      const stats: QueryStats = {
+        totalFiles: allFiles.length,
+        matchedFiles: results.length,
+        executionTimeMs: Date.now() - startTime
+      }
+
+      this.logger.debug(
+        { options, stats },
+        'Query executed'
+      )
+
+      return { results, stats }
+    } catch (error) {
+      this.logger.error({ error, options }, 'Query failed')
+      return {
+        results: [],
+        stats: {
+          totalFiles: 0,
+          matchedFiles: 0,
+          executionTimeMs: Date.now() - startTime
+        }
+      }
+    }
+  }
+
+  /**
+   * Score a file against query options
+   */
+  private scoreFile(file: MarkdownFile, options: QueryOptions): QueryResult {
+    let score = 0
+    const matches: string[] = []
+
+    // Text search
+    if (options.text) {
+      const textScore = this.scoreTextMatch(file, options.text)
+      score += textScore.score
+      matches.push(...textScore.matches)
+    }
+
+    // Tag filter
+    if (options.tags && options.tags.length > 0) {
+      const fileTags = FrontmatterUtils.getTags(file.frontmatter)
+      const matchedTags = options.tags.filter(tag =>
+        fileTags.some(ft => ft.toLowerCase() === tag.toLowerCase())
+      )
+
+      if (matchedTags.length > 0) {
+        score += matchedTags.length * 20
+        matches.push(...matchedTags.map(t => `tag:${t}`))
+      } else {
+        // No tag match means exclude this file
+        return { file, score: 0, matches: [] }
+      }
+    }
+
+    // Status filter
+    if (options.status) {
+      const fileStatus = FrontmatterUtils.getStatus(file.frontmatter)
+      if (fileStatus?.toLowerCase() === options.status.toLowerCase()) {
+        score += 15
+        matches.push(`status:${options.status}`)
+      } else {
+        return { file, score: 0, matches: [] }
+      }
+    }
+
+    // Project filter
+    if (options.project) {
+      const fileProject = FrontmatterUtils.getProject(file.frontmatter)
+      if (fileProject?.toLowerCase() === options.project.toLowerCase()) {
+        score += 25
+        matches.push(`project:${options.project}`)
+      } else {
+        return { file, score: 0, matches: [] }
+      }
+    }
+
+    // Type filter
+    if (options.type) {
+      const fileType = FrontmatterUtils.getType(file.frontmatter)
+      if (fileType?.toLowerCase() === options.type.toLowerCase()) {
+        score += 15
+        matches.push(`type:${options.type}`)
+      } else {
+        return { file, score: 0, matches: [] }
+      }
+    }
+
+    // Tech stack filter
+    if (options.techStack && options.techStack.length > 0) {
+      const fileTechStack = FrontmatterUtils.getTechStack(file.frontmatter)
+      const matchedTech = options.techStack.filter(tech =>
+        fileTechStack.some(ft => ft.toLowerCase() === tech.toLowerCase())
+      )
+
+      if (matchedTech.length > 0) {
+        score += matchedTech.length * 15
+        matches.push(...matchedTech.map(t => `tech:${t}`))
+      } else {
+        return { file, score: 0, matches: [] }
+      }
+    }
+
+    // Date range filter
+    if (options.dateRange) {
+      const dateField = options.dateRange.field || 'updated'
+      const fileDate = FrontmatterUtils.getDate(file.frontmatter, dateField)
+
+      if (fileDate) {
+        const { start, end } = options.dateRange
+
+        if (start && fileDate < start) {
+          return { file, score: 0, matches: [] }
+        }
+        if (end && fileDate > end) {
+          return { file, score: 0, matches: [] }
+        }
+
+        score += 5
+      } else if (options.dateRange.start || options.dateRange.end) {
+        // If date range is specified but file has no date, exclude it
+        return { file, score: 0, matches: [] }
+      }
+    }
+
+    // Boost score if no specific filters but file was matched
+    if (score === 0 && !options.text) {
+      // If no filters applied, give base score
+      score = 1
+    }
+
+    return { file, score, matches }
+  }
+
+  /**
+   * Score text match with term highlighting
+   */
+  private scoreTextMatch(
+    file: MarkdownFile,
+    searchText: string
+  ): { score: number; matches: string[] } {
+    const searchTerms = searchText.toLowerCase().split(/\s+/).filter(Boolean)
+    const content = file.content.toLowerCase()
+    const title = path.basename(file.path, '.md').toLowerCase()
+    const frontmatterText = JSON.stringify(file.frontmatter).toLowerCase()
+
+    let score = 0
+    const matches: string[] = []
+
+    for (const term of searchTerms) {
+      // Check title (highest weight)
+      if (title.includes(term)) {
+        score += 30
+        matches.push(`title:${term}`)
+      }
+
+      // Check frontmatter (medium weight)
+      if (frontmatterText.includes(term)) {
+        score += 15
+        if (!matches.includes(`title:${term}`)) {
+          matches.push(`frontmatter:${term}`)
+        }
+      }
+
+      // Check content (base weight)
+      if (content.includes(term)) {
+        // Count occurrences for scoring
+        const occurrences = (content.match(new RegExp(term, 'gi')) || []).length
+        score += Math.min(occurrences * 2, 20) // Cap at 20 points per term
+        if (!matches.some(m => m.includes(term))) {
+          matches.push(term)
+        }
+      }
+    }
+
+    return { score, matches }
+  }
+
+  /**
+   * Sort results based on options
+   */
+  private sortResults(
+    results: QueryResult[],
+    options: QueryOptions
+  ): QueryResult[] {
+    const sortBy = options.sortBy || 'score'
+    const direction = options.sortDirection || 'desc'
+    const multiplier = direction === 'desc' ? -1 : 1
+
+    return results.sort((a, b) => {
+      switch (sortBy) {
+        case 'score':
+          return (a.score - b.score) * multiplier
+
+        case 'date': {
+          const dateA = FrontmatterUtils.getDate(a.file.frontmatter)
+          const dateB = FrontmatterUtils.getDate(b.file.frontmatter)
+          if (!dateA && !dateB) return 0
+          if (!dateA) return 1
+          if (!dateB) return -1
+          return (dateA.getTime() - dateB.getTime()) * multiplier
+        }
+
+        case 'name': {
+          const nameA = path.basename(a.file.path)
+          const nameB = path.basename(b.file.path)
+          return nameA.localeCompare(nameB) * multiplier
+        }
+
+        default:
+          return (a.score - b.score) * multiplier
+      }
+    })
+  }
+
+  /**
+   * Search by text only (simplified)
+   */
+  async searchText(
+    vaultPath: string,
+    searchText: string,
+    limit: number = 10
+  ): Promise<QueryResult[]> {
+    const { results } = await this.query(vaultPath, { text: searchText, limit })
+    return results
+  }
+
+  /**
+   * Get files by tag
+   */
+  async getByTag(vaultPath: string, tag: string): Promise<QueryResult[]> {
+    const { results } = await this.query(vaultPath, { tags: [tag] })
+    return results
+  }
+
+  /**
+   * Get files by project
+   */
+  async getByProject(
+    vaultPath: string,
+    project: string
+  ): Promise<QueryResult[]> {
+    const { results } = await this.query(vaultPath, { project })
+    return results
+  }
+
+  /**
+   * Get files by document type
+   */
+  async getByType(vaultPath: string, type: string): Promise<QueryResult[]> {
+    const { results } = await this.query(vaultPath, { type })
+    return results
+  }
+
+  /**
+   * Get recently updated files
+   */
+  async getRecentlyUpdated(
+    vaultPath: string,
+    days: number = 7,
+    limit: number = 10
+  ): Promise<QueryResult[]> {
+    const start = new Date()
+    start.setDate(start.getDate() - days)
+
+    const { results } = await this.query(vaultPath, {
+      dateRange: { start },
+      sortBy: 'date',
+      sortDirection: 'desc',
+      limit
+    })
+
+    return results
+  }
+
+  /**
+   * Get all projects with their metadata
+   */
+  async getAllProjects(vaultPath: string): Promise<
+    Array<{
+      name: string
+      status: string
+      contextFile: MarkdownFile | null
+    }>
+  > {
+    const projectsPath = path.join(vaultPath, 'Projects')
+    const projectDirs = await this.reader.getProjectDirectories(projectsPath)
+
+    const projects = await Promise.all(
+      projectDirs.map(async name => {
+        const contextPath = path.join(projectsPath, name, 'context.md')
+        let contextFile: MarkdownFile | null = null
+
+        try {
+          contextFile = await this.reader.readMarkdownFile(contextPath)
+        } catch {
+          // Context file might not exist
+        }
+
+        return {
+          name,
+          status: contextFile
+            ? FrontmatterUtils.getStatus(contextFile.frontmatter) || 'unknown'
+            : 'unknown',
+          contextFile
+        }
+      })
+    )
+
+    return projects
+  }
+
+  /**
+   * Get project files
+   */
+  async getProjectFiles(
+    vaultPath: string,
+    projectName: string
+  ): Promise<MarkdownFile[]> {
+    const projectPath = path.join(vaultPath, 'Projects', projectName)
+    const files = await this.reader.readDirectory(projectPath, false)
+    return this.reader.readMarkdownFiles(files)
+  }
+}