claude-brain 0.14.2 → 0.14.4

package/src/config/validator.ts

@@ -1,184 +1,184 @@
-import fs from 'fs/promises'
-import path from 'path'
-import type { Logger } from 'pino'
-
-export interface ValidationResult {
-  valid: boolean
-  errors: ValidationError[]
-  warnings: ValidationWarning[]
-}
-
-export interface ValidationError {
-  field: string
-  message: string
-  severity: 'error'
-}
-
-export interface ValidationWarning {
-  field: string
-  message: string
-  severity: 'warning'
-}
-
-export class ConfigValidator {
-  private logger: Logger
-
-  constructor(logger: Logger) {
-    this.logger = logger.child({ component: 'config-validator' })
-  }
-
-  async validate(config: any): Promise<ValidationResult> {
-    const errors: ValidationError[] = []
-    const warnings: ValidationWarning[] = []
-
-    await this.validateVaultPath(config.vaultPath, errors, warnings)
-    await this.validateDatabasePath(config.dbPath, errors, warnings)
-    this.validateLogConfig(config, errors, warnings)
-    this.validateServerConfig(config, errors, warnings)
-
-    const valid = errors.length === 0
-
-    return { valid, errors, warnings }
-  }
-
-  private async validateVaultPath(
-    vaultPath: string,
-    errors: ValidationError[],
-    warnings: ValidationWarning[]
-  ): Promise<void> {
-    if (!vaultPath) {
-      errors.push({
-        field: 'vaultPath',
-        message: 'Vault path is required',
-        severity: 'error'
-      })
-      return
-    }
-
-    try {
-      const stat = await fs.stat(vaultPath)
-
-      if (!stat.isDirectory()) {
-        errors.push({
-          field: 'vaultPath',
-          message: 'Vault path must be a directory',
-          severity: 'error'
-        })
-        return
-      }
-
-      const projectsPath = path.join(vaultPath, 'Projects')
-      try {
-        await fs.access(projectsPath)
-      } catch {
-        warnings.push({
-          field: 'vaultPath',
-          message: 'Projects directory not found. It will be created automatically.',
-          severity: 'warning'
-        })
-      }
-
-      try {
-        await fs.access(vaultPath, fs.constants.W_OK)
-      } catch {
-        errors.push({
-          field: 'vaultPath',
-          message: 'Vault path is not writable',
-          severity: 'error'
-        })
-      }
-
-    } catch (error) {
-      errors.push({
-        field: 'vaultPath',
-        message: `Vault path does not exist: ${vaultPath}`,
-        severity: 'error'
-      })
-    }
-  }
-
-  private async validateDatabasePath(
-    dbPath: string,
-    errors: ValidationError[],
-    warnings: ValidationWarning[]
-  ): Promise<void> {
-    if (!dbPath) {
-      errors.push({
-        field: 'dbPath',
-        message: 'Database path is required',
-        severity: 'error'
-      })
-      return
-    }
-
-    const dbDir = path.dirname(dbPath)
-
-    try {
-      await fs.mkdir(dbDir, { recursive: true })
-    } catch (error) {
-      errors.push({
-        field: 'dbPath',
-        message: `Cannot create database directory: ${dbDir}`,
-        severity: 'error'
-      })
-    }
-  }
-
-  private validateLogConfig(
-    config: any,
-    errors: ValidationError[],
-    warnings: ValidationWarning[]
-  ): void {
-    const validLevels = ['error', 'warn', 'info', 'debug']
-
-    if (config.logLevel && !validLevels.includes(config.logLevel)) {
-      warnings.push({
-        field: 'logLevel',
-        message: `Invalid log level: ${config.logLevel}. Using 'info' as default.`,
-        severity: 'warning'
-      })
-    }
-  }
-
-  private validateServerConfig(
-    config: any,
-    errors: ValidationError[],
-    warnings: ValidationWarning[]
-  ): void {
-    if (!config.serverName) {
-      errors.push({
-        field: 'serverName',
-        message: 'Server name is required',
-        severity: 'error'
-      })
-    }
-
-    if (!config.serverVersion) {
-      warnings.push({
-        field: 'serverVersion',
-        message: 'Server version not specified',
-        severity: 'warning'
-      })
-    }
-  }
-
-  async checkSystemRequirements(): Promise<ValidationResult> {
-    const errors: ValidationError[] = []
-    const warnings: ValidationWarning[] = []
-
-    const bunVersion = process.versions.bun
-    if (!bunVersion) {
-      errors.push({
-        field: 'runtime',
-        message: 'Bun runtime not detected. Claude Brain requires Bun.',
-        severity: 'error'
-      })
-    }
-
-    return {
-      valid: errors.length === 0,
-      errors,
-      warnings
-    }
-  }
-}
+import fs from 'fs/promises'
+import path from 'path'
+import type { Logger } from 'pino'
+
+export interface ValidationResult {
+  valid: boolean
+  errors: ValidationError[]
+  warnings: ValidationWarning[]
+}
+
+export interface ValidationError {
+  field: string
+  message: string
+  severity: 'error'
+}
+
+export interface ValidationWarning {
+  field: string
+  message: string
+  severity: 'warning'
+}
+
+export class ConfigValidator {
+  private logger: Logger
+
+  constructor(logger: Logger) {
+    this.logger = logger.child({ component: 'config-validator' })
+  }
+
+  async validate(config: any): Promise<ValidationResult> {
+    const errors: ValidationError[] = []
+    const warnings: ValidationWarning[] = []
+
+    await this.validateVaultPath(config.vaultPath, errors, warnings)
+    await this.validateDatabasePath(config.dbPath, errors, warnings)
+    this.validateLogConfig(config, errors, warnings)
+    this.validateServerConfig(config, errors, warnings)
+
+    const valid = errors.length === 0
+
+    return { valid, errors, warnings }
+  }
+
+  private async validateVaultPath(
+    vaultPath: string,
+    errors: ValidationError[],
+    warnings: ValidationWarning[]
+  ): Promise<void> {
+    if (!vaultPath) {
+      errors.push({
+        field: 'vaultPath',
+        message: 'Vault path is required',
+        severity: 'error'
+      })
+      return
+    }
+
+    try {
+      const stat = await fs.stat(vaultPath)
+
+      if (!stat.isDirectory()) {
+        errors.push({
+          field: 'vaultPath',
+          message: 'Vault path must be a directory',
+          severity: 'error'
+        })
+        return
+      }
+
+      const projectsPath = path.join(vaultPath, 'Projects')
+      try {
+        await fs.access(projectsPath)
+      } catch {
+        warnings.push({
+          field: 'vaultPath',
+          message: 'Projects directory not found. It will be created automatically.',
+          severity: 'warning'
+        })
+      }
+
+      try {
+        await fs.access(vaultPath, fs.constants.W_OK)
+      } catch {
+        errors.push({
+          field: 'vaultPath',
+          message: 'Vault path is not writable',
+          severity: 'error'
+        })
+      }
+
+    } catch (error) {
+      errors.push({
+        field: 'vaultPath',
+        message: `Vault path does not exist: ${vaultPath}`,
+        severity: 'error'
+      })
+    }
+  }
+
+  private async validateDatabasePath(
+    dbPath: string,
+    errors: ValidationError[],
+    warnings: ValidationWarning[]
+  ): Promise<void> {
+    if (!dbPath) {
+      errors.push({
+        field: 'dbPath',
+        message: 'Database path is required',
+        severity: 'error'
+      })
+      return
+    }
+
+    const dbDir = path.dirname(dbPath)
+
+    try {
+      await fs.mkdir(dbDir, { recursive: true })
+    } catch (error) {
+      errors.push({
+        field: 'dbPath',
+        message: `Cannot create database directory: ${dbDir}`,
+        severity: 'error'
+      })
+    }
+  }
+
+  private validateLogConfig(
+    config: any,
+    errors: ValidationError[],
+    warnings: ValidationWarning[]
+  ): void {
+    const validLevels = ['error', 'warn', 'info', 'debug']
+
+    if (config.logLevel && !validLevels.includes(config.logLevel)) {
+      warnings.push({
+        field: 'logLevel',
+        message: `Invalid log level: ${config.logLevel}. Using 'info' as default.`,
+        severity: 'warning'
+      })
+    }
+  }
+
+  private validateServerConfig(
+    config: any,
+    errors: ValidationError[],
+    warnings: ValidationWarning[]
+  ): void {
+    if (!config.serverName) {
+      errors.push({
+        field: 'serverName',
+        message: 'Server name is required',
+        severity: 'error'
+      })
+    }
+
+    if (!config.serverVersion) {
+      warnings.push({
+        field: 'serverVersion',
+        message: 'Server version not specified',
+        severity: 'warning'
+      })
+    }
+  }
+
+  async checkSystemRequirements(): Promise<ValidationResult> {
+    const errors: ValidationError[] = []
+    const warnings: ValidationWarning[] = []
+
+    const bunVersion = process.versions.bun
+    if (!bunVersion) {
+      errors.push({
+        field: 'runtime',
+        message: 'Bun runtime not detected. Claude Brain requires Bun.',
+        severity: 'error'
+      })
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    }
+  }
+}

package/src/config/watcher.ts

@@ -1,86 +1,86 @@
-import { watch, type FSWatcher } from 'node:fs'
-import { EventEmitter } from 'node:events'
-import { loadConfig, getConfigFilePath } from './loader'
-import type { Config } from './schema'
-
-export interface ConfigWatcherEvents {
-  change: (config: Config) => void
-  error: (error: Error) => void
-}
-
-/** Watches the config file for changes and emits events */
-export class ConfigWatcher extends EventEmitter {
-  private watcher: FSWatcher | null = null
-  private configPath: string
-  private currentConfig: Config | null = null
-  private debounceTimer: Timer | null = null
-  private readonly debounceMs = 100
-
-  constructor(basePath: string = process.cwd()) {
-    super()
-    this.configPath = getConfigFilePath(basePath)
-  }
-
-  /** Start watching the config file */
-  async start(): Promise<void> {
-    try {
-      this.currentConfig = await loadConfig()
-
-      this.watcher = watch(this.configPath, (eventType) => {
-        if (eventType === 'change') {
-          this.handleChange()
-        }
-      })
-
-      this.watcher.on('error', (error) => {
-        this.emit('error', error)
-      })
-    } catch (error) {
-      // Config file might not exist yet, that's ok
-      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
-        throw error
-      }
-    }
-  }
-
-  /** Stop watching the config file */
-  stop(): void {
-    if (this.watcher) {
-      this.watcher.close()
-      this.watcher = null
-    }
-    if (this.debounceTimer) {
-      clearTimeout(this.debounceTimer)
-      this.debounceTimer = null
-    }
-  }
-
-  /** Get the current configuration */
-  getConfig(): Config | null {
-    return this.currentConfig
-  }
-
-  private handleChange(): void {
-    // Debounce rapid changes
-    if (this.debounceTimer) {
-      clearTimeout(this.debounceTimer)
-    }
-
-    this.debounceTimer = setTimeout(async () => {
-      try {
-        const newConfig = await loadConfig()
-        this.currentConfig = newConfig
-        this.emit('change', newConfig)
-      } catch (error) {
-        this.emit('error', error instanceof Error ? error : new Error(String(error)))
-      }
-    }, this.debounceMs)
-  }
-}
-
-/** Create and start a config watcher */
-export async function createConfigWatcher(basePath?: string): Promise<ConfigWatcher> {
-  const watcher = new ConfigWatcher(basePath)
-  await watcher.start()
-  return watcher
-}
+import { watch, type FSWatcher } from 'node:fs'
+import { EventEmitter } from 'node:events'
+import { loadConfig, getConfigFilePath } from './loader'
+import type { Config } from './schema'
+
+export interface ConfigWatcherEvents {
+  change: (config: Config) => void
+  error: (error: Error) => void
+}
+
+/** Watches the config file for changes and emits events */
+export class ConfigWatcher extends EventEmitter {
+  private watcher: FSWatcher | null = null
+  private configPath: string
+  private currentConfig: Config | null = null
+  private debounceTimer: Timer | null = null
+  private readonly debounceMs = 100
+
+  constructor(basePath: string = process.cwd()) {
+    super()
+    this.configPath = getConfigFilePath(basePath)
+  }
+
+  /** Start watching the config file */
+  async start(): Promise<void> {
+    try {
+      this.currentConfig = await loadConfig()
+
+      this.watcher = watch(this.configPath, (eventType) => {
+        if (eventType === 'change') {
+          this.handleChange()
+        }
+      })
+
+      this.watcher.on('error', (error) => {
+        this.emit('error', error)
+      })
+    } catch (error) {
+      // Config file might not exist yet, that's ok
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+        throw error
+      }
+    }
+  }
+
+  /** Stop watching the config file */
+  stop(): void {
+    if (this.watcher) {
+      this.watcher.close()
+      this.watcher = null
+    }
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer)
+      this.debounceTimer = null
+    }
+  }
+
+  /** Get the current configuration */
+  getConfig(): Config | null {
+    return this.currentConfig
+  }
+
+  private handleChange(): void {
+    // Debounce rapid changes
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer)
+    }
+
+    this.debounceTimer = setTimeout(async () => {
+      try {
+        const newConfig = await loadConfig()
+        this.currentConfig = newConfig
+        this.emit('change', newConfig)
+      } catch (error) {
+        this.emit('error', error instanceof Error ? error : new Error(String(error)))
+      }
+    }, this.debounceMs)
+  }
+}
+
+/** Create and start a config watcher */
+export async function createConfigWatcher(basePath?: string): Promise<ConfigWatcher> {
+  const watcher = new ConfigWatcher(basePath)
+  await watcher.start()
+  return watcher
+}