claude-brain 0.14.2 → 0.14.4

package/src/vault/watcher.ts

@@ -1,277 +1,277 @@
-/**
- * Vault File Watcher
- * Monitor vault for changes and emit events for real-time synchronization
- */
-
-import { watch, type FSWatcher } from 'fs'
-import fs from 'fs/promises'
-import path from 'path'
-import { EventEmitter } from 'events'
-import type { Logger } from 'pino'
-
-export type FileChangeType = 'created' | 'modified' | 'deleted'
-
-export interface FileChangeEvent {
-  type: FileChangeType
-  path: string
-  timestamp: Date
-}
-
-export interface WatcherStatus {
-  watching: string[]
-  activeDebounces: number
-}
-
-export interface VaultWatcherEvents {
-  change: (event: FileChangeEvent) => void
-  created: (event: FileChangeEvent) => void
-  modified: (event: FileChangeEvent) => void
-  deleted: (event: FileChangeEvent) => void
-  error: (error: Error, path: string) => void
-}
-
-export class VaultWatcher extends EventEmitter {
-  private watchers: Map<string, FSWatcher>
-  private logger: Logger
-  private debounceTimers: Map<string, NodeJS.Timeout>
-  private debounceMs: number
-  private fileStates: Map<string, boolean> // Track if file exists
-
-  constructor(logger: Logger, debounceMs: number = 500) {
-    super()
-    this.logger = logger.child({ component: 'vault-watcher' })
-    this.watchers = new Map()
-    this.debounceTimers = new Map()
-    this.debounceMs = debounceMs
-    this.fileStates = new Map()
-  }
-
-  /**
-   * Type-safe event listener
-   */
-  on<K extends keyof VaultWatcherEvents>(
-    event: K,
-    listener: VaultWatcherEvents[K]
-  ): this {
-    return super.on(event, listener)
-  }
-
-  /**
-   * Type-safe emit
-   */
-  emit<K extends keyof VaultWatcherEvents>(
-    event: K,
-    ...args: Parameters<VaultWatcherEvents[K]>
-  ): boolean {
-    return super.emit(event, ...args)
-  }
-
-  /**
-   * Start watching a directory
-   */
-  watch(dirPath: string, recursive: boolean = true): void {
-    if (this.watchers.has(dirPath)) {
-      this.logger.warn({ dirPath }, 'Already watching directory')
-      return
-    }
-
-    try {
-      const watcher = watch(
-        dirPath,
-        { recursive },
-        (eventType, filename) => {
-          if (!filename || !filename.endsWith('.md')) {
-            return
-          }
-
-          const fullPath = path.join(dirPath, filename)
-          this.handleFileChange(eventType, fullPath)
-        }
-      )
-
-      watcher.on('error', (error) => {
-        this.logger.error({ error, dirPath }, 'Watcher error')
-        this.emit('error', error, dirPath)
-      })
-
-      this.watchers.set(dirPath, watcher)
-      this.logger.info({ dirPath, recursive }, 'Started watching directory')
-    } catch (error) {
-      this.logger.error({ error, dirPath }, 'Failed to start watching')
-    }
-  }
-
-  /**
-   * Stop watching a directory
-   */
-  unwatch(dirPath: string): void {
-    const watcher = this.watchers.get(dirPath)
-    if (watcher) {
-      watcher.close()
-      this.watchers.delete(dirPath)
-      this.logger.info({ dirPath }, 'Stopped watching directory')
-    }
-  }
-
-  /**
-   * Stop all watchers
-   */
-  unwatchAll(): void {
-    for (const [dirPath, watcher] of this.watchers) {
-      watcher.close()
-      this.logger.debug({ dirPath }, 'Watcher closed')
-    }
-    this.watchers.clear()
-
-    // Clear all debounce timers
-    for (const timer of this.debounceTimers.values()) {
-      clearTimeout(timer)
-    }
-    this.debounceTimers.clear()
-
-    // Clear file states
-    this.fileStates.clear()
-
-    this.logger.info('All watchers stopped')
-  }
-
-  /**
-   * Handle file change with debouncing
-   */
-  private handleFileChange(eventType: string, filePath: string): void {
-    // Clear existing timer for this file
-    const existingTimer = this.debounceTimers.get(filePath)
-    if (existingTimer) {
-      clearTimeout(existingTimer)
-    }
-
-    // Set new timer
-    const timer = setTimeout(async () => {
-      await this.emitFileChange(eventType, filePath)
-      this.debounceTimers.delete(filePath)
-    }, this.debounceMs)
-
-    this.debounceTimers.set(filePath, timer)
-  }
-
-  /**
-   * Emit file change event after determining change type
-   */
-  private async emitFileChange(eventType: string, filePath: string): Promise<void> {
-    // Determine change type by checking file existence
-    let changeType: FileChangeType
-    const previouslyExisted = this.fileStates.get(filePath) ?? false
-    let currentlyExists = false
-
-    try {
-      await fs.access(filePath)
-      currentlyExists = true
-    } catch {
-      currentlyExists = false
-    }
-
-    // Update file state
-    this.fileStates.set(filePath, currentlyExists)
-
-    // Determine the type of change
-    if (eventType === 'rename') {
-      if (currentlyExists && !previouslyExisted) {
-        changeType = 'created'
-      } else if (!currentlyExists && previouslyExisted) {
-        changeType = 'deleted'
-      } else if (currentlyExists) {
-        // File was renamed to this path from somewhere else
-        changeType = 'created'
-      } else {
-        // File was renamed away from this path
-        changeType = 'deleted'
-      }
-    } else {
-      // eventType === 'change'
-      changeType = 'modified'
-    }
-
-    const event: FileChangeEvent = {
-      type: changeType,
-      path: filePath,
-      timestamp: new Date()
-    }
-
-    this.logger.debug({ event }, 'File change detected')
-    this.emit('change', event)
-    this.emit(changeType, event)
-  }
-
-  /**
-   * Force refresh of file states for a directory
-   */
-  async refreshFileStates(dirPath: string): Promise<void> {
-    try {
-      const files = await this.scanDirectory(dirPath)
-      for (const file of files) {
-        this.fileStates.set(file, true)
-      }
-      this.logger.debug({ dirPath, fileCount: files.length }, 'File states refreshed')
-    } catch (error) {
-      this.logger.error({ error, dirPath }, 'Failed to refresh file states')
-    }
-  }
-
-  /**
-   * Scan directory for markdown files
-   */
-  private async scanDirectory(dirPath: string): Promise<string[]> {
-    const files: string[] = []
-
-    try {
-      const entries = await fs.readdir(dirPath, { withFileTypes: true })
-
-      for (const entry of entries) {
-        const fullPath = path.join(dirPath, entry.name)
-
-        if (entry.isDirectory()) {
-          const subFiles = await this.scanDirectory(fullPath)
-          files.push(...subFiles)
-        } else if (entry.isFile() && entry.name.endsWith('.md')) {
-          files.push(fullPath)
-        }
-      }
-    } catch {
-      // Directory might not exist yet
-    }
-
-    return files
-  }
-
-  /**
-   * Get watcher status
-   */
-  getStatus(): WatcherStatus {
-    return {
-      watching: Array.from(this.watchers.keys()),
-      activeDebounces: this.debounceTimers.size
-    }
-  }
-
-  /**
-   * Check if a path is being watched
-   */
-  isWatching(dirPath: string): boolean {
-    return this.watchers.has(dirPath)
-  }
-
-  /**
-   * Get the number of active watchers
-   */
-  getWatcherCount(): number {
-    return this.watchers.size
-  }
-
-  /**
-   * Update debounce delay
-   */
-  setDebounceMs(ms: number): void {
-    this.debounceMs = ms
-    this.logger.info({ debounceMs: ms }, 'Debounce delay updated')
-  }
-}
+/**
+ * Vault File Watcher
+ * Monitor vault for changes and emit events for real-time synchronization
+ */
+
+import { watch, type FSWatcher } from 'fs'
+import fs from 'fs/promises'
+import path from 'path'
+import { EventEmitter } from 'events'
+import type { Logger } from 'pino'
+
+export type FileChangeType = 'created' | 'modified' | 'deleted'
+
+export interface FileChangeEvent {
+  type: FileChangeType
+  path: string
+  timestamp: Date
+}
+
+export interface WatcherStatus {
+  watching: string[]
+  activeDebounces: number
+}
+
+export interface VaultWatcherEvents {
+  change: (event: FileChangeEvent) => void
+  created: (event: FileChangeEvent) => void
+  modified: (event: FileChangeEvent) => void
+  deleted: (event: FileChangeEvent) => void
+  error: (error: Error, path: string) => void
+}
+
+export class VaultWatcher extends EventEmitter {
+  private watchers: Map<string, FSWatcher>
+  private logger: Logger
+  private debounceTimers: Map<string, NodeJS.Timeout>
+  private debounceMs: number
+  private fileStates: Map<string, boolean> // Track if file exists
+
+  constructor(logger: Logger, debounceMs: number = 500) {
+    super()
+    this.logger = logger.child({ component: 'vault-watcher' })
+    this.watchers = new Map()
+    this.debounceTimers = new Map()
+    this.debounceMs = debounceMs
+    this.fileStates = new Map()
+  }
+
+  /**
+   * Type-safe event listener
+   */
+  on<K extends keyof VaultWatcherEvents>(
+    event: K,
+    listener: VaultWatcherEvents[K]
+  ): this {
+    return super.on(event, listener)
+  }
+
+  /**
+   * Type-safe emit
+   */
+  emit<K extends keyof VaultWatcherEvents>(
+    event: K,
+    ...args: Parameters<VaultWatcherEvents[K]>
+  ): boolean {
+    return super.emit(event, ...args)
+  }
+
+  /**
+   * Start watching a directory
+   */
+  watch(dirPath: string, recursive: boolean = true): void {
+    if (this.watchers.has(dirPath)) {
+      this.logger.warn({ dirPath }, 'Already watching directory')
+      return
+    }
+
+    try {
+      const watcher = watch(
+        dirPath,
+        { recursive },
+        (eventType, filename) => {
+          if (!filename || !filename.endsWith('.md')) {
+            return
+          }
+
+          const fullPath = path.join(dirPath, filename)
+          this.handleFileChange(eventType, fullPath)
+        }
+      )
+
+      watcher.on('error', (error) => {
+        this.logger.error({ error, dirPath }, 'Watcher error')
+        this.emit('error', error, dirPath)
+      })
+
+      this.watchers.set(dirPath, watcher)
+      this.logger.info({ dirPath, recursive }, 'Started watching directory')
+    } catch (error) {
+      this.logger.error({ error, dirPath }, 'Failed to start watching')
+    }
+  }
+
+  /**
+   * Stop watching a directory
+   */
+  unwatch(dirPath: string): void {
+    const watcher = this.watchers.get(dirPath)
+    if (watcher) {
+      watcher.close()
+      this.watchers.delete(dirPath)
+      this.logger.info({ dirPath }, 'Stopped watching directory')
+    }
+  }
+
+  /**
+   * Stop all watchers
+   */
+  unwatchAll(): void {
+    for (const [dirPath, watcher] of this.watchers) {
+      watcher.close()
+      this.logger.debug({ dirPath }, 'Watcher closed')
+    }
+    this.watchers.clear()
+
+    // Clear all debounce timers
+    for (const timer of this.debounceTimers.values()) {
+      clearTimeout(timer)
+    }
+    this.debounceTimers.clear()
+
+    // Clear file states
+    this.fileStates.clear()
+
+    this.logger.info('All watchers stopped')
+  }
+
+  /**
+   * Handle file change with debouncing
+   */
+  private handleFileChange(eventType: string, filePath: string): void {
+    // Clear existing timer for this file
+    const existingTimer = this.debounceTimers.get(filePath)
+    if (existingTimer) {
+      clearTimeout(existingTimer)
+    }
+
+    // Set new timer
+    const timer = setTimeout(async () => {
+      await this.emitFileChange(eventType, filePath)
+      this.debounceTimers.delete(filePath)
+    }, this.debounceMs)
+
+    this.debounceTimers.set(filePath, timer)
+  }
+
+  /**
+   * Emit file change event after determining change type
+   */
+  private async emitFileChange(eventType: string, filePath: string): Promise<void> {
+    // Determine change type by checking file existence
+    let changeType: FileChangeType
+    const previouslyExisted = this.fileStates.get(filePath) ?? false
+    let currentlyExists = false
+
+    try {
+      await fs.access(filePath)
+      currentlyExists = true
+    } catch {
+      currentlyExists = false
+    }
+
+    // Update file state
+    this.fileStates.set(filePath, currentlyExists)
+
+    // Determine the type of change
+    if (eventType === 'rename') {
+      if (currentlyExists && !previouslyExisted) {
+        changeType = 'created'
+      } else if (!currentlyExists && previouslyExisted) {
+        changeType = 'deleted'
+      } else if (currentlyExists) {
+        // File was renamed to this path from somewhere else
+        changeType = 'created'
+      } else {
+        // File was renamed away from this path
+        changeType = 'deleted'
+      }
+    } else {
+      // eventType === 'change'
+      changeType = 'modified'
+    }
+
+    const event: FileChangeEvent = {
+      type: changeType,
+      path: filePath,
+      timestamp: new Date()
+    }
+
+    this.logger.debug({ event }, 'File change detected')
+    this.emit('change', event)
+    this.emit(changeType, event)
+  }
+
+  /**
+   * Force refresh of file states for a directory
+   */
+  async refreshFileStates(dirPath: string): Promise<void> {
+    try {
+      const files = await this.scanDirectory(dirPath)
+      for (const file of files) {
+        this.fileStates.set(file, true)
+      }
+      this.logger.debug({ dirPath, fileCount: files.length }, 'File states refreshed')
+    } catch (error) {
+      this.logger.error({ error, dirPath }, 'Failed to refresh file states')
+    }
+  }
+
+  /**
+   * Scan directory for markdown files
+   */
+  private async scanDirectory(dirPath: string): Promise<string[]> {
+    const files: string[] = []
+
+    try {
+      const entries = await fs.readdir(dirPath, { withFileTypes: true })
+
+      for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name)
+
+        if (entry.isDirectory()) {
+          const subFiles = await this.scanDirectory(fullPath)
+          files.push(...subFiles)
+        } else if (entry.isFile() && entry.name.endsWith('.md')) {
+          files.push(fullPath)
+        }
+      }
+    } catch {
+      // Directory might not exist yet
+    }
+
+    return files
+  }
+
+  /**
+   * Get watcher status
+   */
+  getStatus(): WatcherStatus {
+    return {
+      watching: Array.from(this.watchers.keys()),
+      activeDebounces: this.debounceTimers.size
+    }
+  }
+
+  /**
+   * Check if a path is being watched
+   */
+  isWatching(dirPath: string): boolean {
+    return this.watchers.has(dirPath)
+  }
+
+  /**
+   * Get the number of active watchers
+   */
+  getWatcherCount(): number {
+    return this.watchers.size
+  }
+
+  /**
+   * Update debounce delay
+   */
+  setDebounceMs(ms: number): void {
+    this.debounceMs = ms
+    this.logger.info({ debounceMs: ms }, 'Debounce delay updated')
+  }
+}