claude-brain 0.14.2 → 0.14.4

package/src/vault/reader.ts

@@ -1,264 +1,264 @@
-/**
- * Vault File Reader
- * Safe, efficient file reading utilities with caching and frontmatter parsing
- */
-
-import fs from 'fs/promises'
-import path from 'path'
-import matter from 'gray-matter'
-import type { Logger } from 'pino'
-import type { MarkdownFile, Frontmatter } from './types'
-
-export interface CacheStats {
-  size: number
-  files: string[]
-}
-
-export class VaultReader {
-  private cache: Map<string, MarkdownFile>
-  private cacheTimestamps: Map<string, number>
-  private logger: Logger
-  private maxCacheSize: number
-  private cacheMaxAge: number // milliseconds
-
-  constructor(
-    logger: Logger,
-    options: { maxCacheSize?: number; cacheMaxAge?: number } = {}
-  ) {
-    this.logger = logger.child({ component: 'vault-reader' })
-    this.cache = new Map()
-    this.cacheTimestamps = new Map()
-    this.maxCacheSize = options.maxCacheSize ?? 100
-    this.cacheMaxAge = options.cacheMaxAge ?? 5 * 60 * 1000 // 5 minutes default
-  }
-
-  /**
-   * Read a markdown file with frontmatter
-   */
-  async readMarkdownFile(
-    filePath: string,
-    useCache: boolean = true
-  ): Promise<MarkdownFile> {
-    // Check cache first
-    if (useCache && this.isCacheValid(filePath)) {
-      this.logger.debug({ filePath }, 'Cache hit')
-      return this.cache.get(filePath)!
-    }
-
-    try {
-      // Check if file exists
-      await fs.access(filePath)
-
-      // Read file content
-      const rawContent = await fs.readFile(filePath, 'utf-8')
-
-      // Parse frontmatter
-      const { data, content } = matter(rawContent)
-
-      const result: MarkdownFile = {
-        path: filePath,
-        frontmatter: data as Frontmatter,
-        content: content.trim(),
-        rawContent
-      }
-
-      // Cache the result
-      this.addToCache(filePath, result)
-
-      this.logger.debug({ filePath }, 'File read successfully')
-      return result
-    } catch (error) {
-      this.logger.error({ error, filePath }, 'Failed to read file')
-      throw new Error(`Failed to read file ${filePath}: ${error}`)
-    }
-  }
-
-  /**
-   * Read multiple files
-   */
-  async readMarkdownFiles(
-    filePaths: string[],
-    useCache: boolean = true
-  ): Promise<MarkdownFile[]> {
-    return Promise.all(
-      filePaths.map(fp => this.readMarkdownFile(fp, useCache))
-    )
-  }
-
-  /**
-   * Check if file exists
-   */
-  async fileExists(filePath: string): Promise<boolean> {
-    try {
-      await fs.access(filePath)
-      return true
-    } catch {
-      return false
-    }
-  }
-
-  /**
-   * Read directory contents
-   */
-  async readDirectory(
-    dirPath: string,
-    recursive: boolean = false
-  ): Promise<string[]> {
-    try {
-      const entries = await fs.readdir(dirPath, { withFileTypes: true })
-      let files: string[] = []
-
-      for (const entry of entries) {
-        const fullPath = path.join(dirPath, entry.name)
-
-        if (entry.isDirectory() && recursive) {
-          const subFiles = await this.readDirectory(fullPath, true)
-          files = files.concat(subFiles)
-        } else if (entry.isFile() && entry.name.endsWith('.md')) {
-          files.push(fullPath)
-        }
-      }
-
-      return files
-    } catch (error) {
-      this.logger.error({ error, dirPath }, 'Failed to read directory')
-      return []
-    }
-  }
-
-  /**
-   * Get all project directories
-   */
-  async getProjectDirectories(projectsPath: string): Promise<string[]> {
-    try {
-      const entries = await fs.readdir(projectsPath, { withFileTypes: true })
-      return entries
-        .filter(entry => entry.isDirectory())
-        .map(entry => entry.name)
-    } catch (error) {
-      this.logger.error({ error, projectsPath }, 'Failed to get projects')
-      return []
-    }
-  }
-
-  /**
-   * Get file stats
-   */
-  async getFileStats(filePath: string): Promise<{
-    size: number
-    created: Date
-    modified: Date
-  } | null> {
-    try {
-      const stats = await fs.stat(filePath)
-      return {
-        size: stats.size,
-        created: stats.birthtime,
-        modified: stats.mtime
-      }
-    } catch {
-      return null
-    }
-  }
-
-  /**
-   * Check if cache entry is valid
-   */
-  private isCacheValid(filePath: string): boolean {
-    if (!this.cache.has(filePath)) {
-      return false
-    }
-
-    const timestamp = this.cacheTimestamps.get(filePath)
-    if (!timestamp) {
-      return false
-    }
-
-    return Date.now() - timestamp < this.cacheMaxAge
-  }
-
-  /**
-   * Add item to cache with LRU eviction
-   */
-  private addToCache(filePath: string, file: MarkdownFile): void {
-    // Evict oldest entries if cache is full
-    if (this.cache.size >= this.maxCacheSize) {
-      const oldestKey = this.findOldestCacheEntry()
-      if (oldestKey) {
-        this.cache.delete(oldestKey)
-        this.cacheTimestamps.delete(oldestKey)
-        this.logger.debug({ filePath: oldestKey }, 'Cache entry evicted')
-      }
-    }
-
-    this.cache.set(filePath, file)
-    this.cacheTimestamps.set(filePath, Date.now())
-  }
-
-  /**
-   * Find the oldest cache entry
-   */
-  private findOldestCacheEntry(): string | null {
-    let oldestKey: string | null = null
-    let oldestTime = Infinity
-
-    for (const [key, timestamp] of this.cacheTimestamps) {
-      if (timestamp < oldestTime) {
-        oldestTime = timestamp
-        oldestKey = key
-      }
-    }
-
-    return oldestKey
-  }
-
-  /**
-   * Invalidate cache for a file
-   */
-  invalidateCache(filePath: string): void {
-    this.cache.delete(filePath)
-    this.cacheTimestamps.delete(filePath)
-    this.logger.debug({ filePath }, 'Cache invalidated')
-  }
-
-  /**
-   * Clear entire cache
-   */
-  clearCache(): void {
-    this.cache.clear()
-    this.cacheTimestamps.clear()
-    this.logger.debug('Cache cleared')
-  }
-
-  /**
-   * Get cache statistics
-   */
-  getCacheStats(): CacheStats {
-    return {
-      size: this.cache.size,
-      files: Array.from(this.cache.keys())
-    }
-  }
-
-  /**
-   * Clean expired cache entries
-   */
-  cleanExpiredCache(): number {
-    let cleaned = 0
-    const now = Date.now()
-
-    for (const [key, timestamp] of this.cacheTimestamps) {
-      if (now - timestamp >= this.cacheMaxAge) {
-        this.cache.delete(key)
-        this.cacheTimestamps.delete(key)
-        cleaned++
-      }
-    }
-
-    if (cleaned > 0) {
-      this.logger.debug({ cleaned }, 'Expired cache entries cleaned')
-    }
-
-    return cleaned
-  }
-}
+/**
+ * Vault File Reader
+ * Safe, efficient file reading utilities with caching and frontmatter parsing
+ */
+
+import fs from 'fs/promises'
+import path from 'path'
+import matter from 'gray-matter'
+import type { Logger } from 'pino'
+import type { MarkdownFile, Frontmatter } from './types'
+
+export interface CacheStats {
+  size: number
+  files: string[]
+}
+
+export class VaultReader {
+  private cache: Map<string, MarkdownFile>
+  private cacheTimestamps: Map<string, number>
+  private logger: Logger
+  private maxCacheSize: number
+  private cacheMaxAge: number // milliseconds
+
+  constructor(
+    logger: Logger,
+    options: { maxCacheSize?: number; cacheMaxAge?: number } = {}
+  ) {
+    this.logger = logger.child({ component: 'vault-reader' })
+    this.cache = new Map()
+    this.cacheTimestamps = new Map()
+    this.maxCacheSize = options.maxCacheSize ?? 100
+    this.cacheMaxAge = options.cacheMaxAge ?? 5 * 60 * 1000 // 5 minutes default
+  }
+
+  /**
+   * Read a markdown file with frontmatter
+   */
+  async readMarkdownFile(
+    filePath: string,
+    useCache: boolean = true
+  ): Promise<MarkdownFile> {
+    // Check cache first
+    if (useCache && this.isCacheValid(filePath)) {
+      this.logger.debug({ filePath }, 'Cache hit')
+      return this.cache.get(filePath)!
+    }
+
+    try {
+      // Check if file exists
+      await fs.access(filePath)
+
+      // Read file content
+      const rawContent = await fs.readFile(filePath, 'utf-8')
+
+      // Parse frontmatter
+      const { data, content } = matter(rawContent)
+
+      const result: MarkdownFile = {
+        path: filePath,
+        frontmatter: data as Frontmatter,
+        content: content.trim(),
+        rawContent
+      }
+
+      // Cache the result
+      this.addToCache(filePath, result)
+
+      this.logger.debug({ filePath }, 'File read successfully')
+      return result
+    } catch (error) {
+      this.logger.error({ error, filePath }, 'Failed to read file')
+      throw new Error(`Failed to read file ${filePath}: ${error}`)
+    }
+  }
+
+  /**
+   * Read multiple files
+   */
+  async readMarkdownFiles(
+    filePaths: string[],
+    useCache: boolean = true
+  ): Promise<MarkdownFile[]> {
+    return Promise.all(
+      filePaths.map(fp => this.readMarkdownFile(fp, useCache))
+    )
+  }
+
+  /**
+   * Check if file exists
+   */
+  async fileExists(filePath: string): Promise<boolean> {
+    try {
+      await fs.access(filePath)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Read directory contents
+   */
+  async readDirectory(
+    dirPath: string,
+    recursive: boolean = false
+  ): Promise<string[]> {
+    try {
+      const entries = await fs.readdir(dirPath, { withFileTypes: true })
+      let files: string[] = []
+
+      for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name)
+
+        if (entry.isDirectory() && recursive) {
+          const subFiles = await this.readDirectory(fullPath, true)
+          files = files.concat(subFiles)
+        } else if (entry.isFile() && entry.name.endsWith('.md')) {
+          files.push(fullPath)
+        }
+      }
+
+      return files
+    } catch (error) {
+      this.logger.error({ error, dirPath }, 'Failed to read directory')
+      return []
+    }
+  }
+
+  /**
+   * Get all project directories
+   */
+  async getProjectDirectories(projectsPath: string): Promise<string[]> {
+    try {
+      const entries = await fs.readdir(projectsPath, { withFileTypes: true })
+      return entries
+        .filter(entry => entry.isDirectory())
+        .map(entry => entry.name)
+    } catch (error) {
+      this.logger.error({ error, projectsPath }, 'Failed to get projects')
+      return []
+    }
+  }
+
+  /**
+   * Get file stats
+   */
+  async getFileStats(filePath: string): Promise<{
+    size: number
+    created: Date
+    modified: Date
+  } | null> {
+    try {
+      const stats = await fs.stat(filePath)
+      return {
+        size: stats.size,
+        created: stats.birthtime,
+        modified: stats.mtime
+      }
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Check if cache entry is valid
+   */
+  private isCacheValid(filePath: string): boolean {
+    if (!this.cache.has(filePath)) {
+      return false
+    }
+
+    const timestamp = this.cacheTimestamps.get(filePath)
+    if (!timestamp) {
+      return false
+    }
+
+    return Date.now() - timestamp < this.cacheMaxAge
+  }
+
+  /**
+   * Add item to cache with LRU eviction
+   */
+  private addToCache(filePath: string, file: MarkdownFile): void {
+    // Evict oldest entries if cache is full
+    if (this.cache.size >= this.maxCacheSize) {
+      const oldestKey = this.findOldestCacheEntry()
+      if (oldestKey) {
+        this.cache.delete(oldestKey)
+        this.cacheTimestamps.delete(oldestKey)
+        this.logger.debug({ filePath: oldestKey }, 'Cache entry evicted')
+      }
+    }
+
+    this.cache.set(filePath, file)
+    this.cacheTimestamps.set(filePath, Date.now())
+  }
+
+  /**
+   * Find the oldest cache entry
+   */
+  private findOldestCacheEntry(): string | null {
+    let oldestKey: string | null = null
+    let oldestTime = Infinity
+
+    for (const [key, timestamp] of this.cacheTimestamps) {
+      if (timestamp < oldestTime) {
+        oldestTime = timestamp
+        oldestKey = key
+      }
+    }
+
+    return oldestKey
+  }
+
+  /**
+   * Invalidate cache for a file
+   */
+  invalidateCache(filePath: string): void {
+    this.cache.delete(filePath)
+    this.cacheTimestamps.delete(filePath)
+    this.logger.debug({ filePath }, 'Cache invalidated')
+  }
+
+  /**
+   * Clear entire cache
+   */
+  clearCache(): void {
+    this.cache.clear()
+    this.cacheTimestamps.clear()
+    this.logger.debug('Cache cleared')
+  }
+
+  /**
+   * Get cache statistics
+   */
+  getCacheStats(): CacheStats {
+    return {
+      size: this.cache.size,
+      files: Array.from(this.cache.keys())
+    }
+  }
+
+  /**
+   * Clean expired cache entries
+   */
+  cleanExpiredCache(): number {
+    let cleaned = 0
+    const now = Date.now()
+
+    for (const [key, timestamp] of this.cacheTimestamps) {
+      if (now - timestamp >= this.cacheMaxAge) {
+        this.cache.delete(key)
+        this.cacheTimestamps.delete(key)
+        cleaned++
+      }
+    }
+
+    if (cleaned > 0) {
+      this.logger.debug({ cleaned }, 'Expired cache entries cleaned')
+    }
+
+    return cleaned
+  }
+}