claude-brain 0.30.2 → 0.30.3

package/src/config/validator.ts

@@ -1,182 +1,182 @@
-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 {
-  constructor(_logger: Logger) {
-    // Logger available for future use
-  }
-
-  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 {
+  constructor(_logger: Logger) {
+    // Logger available for future use
+  }
+
+  async validate(config: Record<string, unknown>): Promise<ValidationResult> {
+    const errors: ValidationError[] = []
+    const warnings: ValidationWarning[] = []
+
+    await this.validateVaultPath(config.vaultPath as string, errors, warnings)
+    await this.validateDatabasePath(config.dbPath as string, 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: Record<string, unknown>,
+    _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: Record<string, unknown>,
+    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
+    }
+  }
+}