claude-brain 0.14.2 → 0.14.4

package/src/health/index.ts

@@ -1,229 +1,229 @@
-import { loadConfig } from '@/config'
-import { ConfigValidator } from '@/config/validator'
-import { resolveHomePath } from '@/config/home'
-import { createLogger } from '@/utils/logger'
-import { VaultManager } from '@/vault'
-import { MemoryManager } from '@/memory'
-import { ContextManager } from '@/context'
-
-export interface HealthStatus {
-  overall: 'healthy' | 'degraded' | 'unhealthy'
-  components: ComponentHealth[]
-  timestamp: Date
-}
-
-export interface ComponentHealth {
-  name: string
-  status: 'healthy' | 'degraded' | 'unhealthy'
-  message: string
-  details?: Record<string, any>
-}
-
-export class HealthChecker {
-  private logger: any
-
-  constructor(logger: any) {
-    this.logger = logger.child({ component: 'health-checker' })
-  }
-
-  async check(): Promise<HealthStatus> {
-    console.log('🏥 Running health checks...\n')
-
-    const components: ComponentHealth[] = []
-
-    components.push(await this.checkConfiguration())
-    components.push(await this.checkVault())
-    components.push(await this.checkMemory())
-    components.push(await this.checkContext())
-
-    const hasUnhealthy = components.some(c => c.status === 'unhealthy')
-    const hasDegraded = components.some(c => c.status === 'degraded')
-
-    const overall = hasUnhealthy ? 'unhealthy' : hasDegraded ? 'degraded' : 'healthy'
-
-    return {
-      overall,
-      components,
-      timestamp: new Date()
-    }
-  }
-
-  private async checkConfiguration(): Promise<ComponentHealth> {
-    try {
-      const config = await loadConfig()
-      const validator = new ConfigValidator(this.logger)
-      const result = await validator.validate(config)
-
-      if (!result.valid) {
-        return {
-          name: 'Configuration',
-          status: 'unhealthy',
-          message: `${result.errors.length} configuration error(s)`,
-          details: { errors: result.errors }
-        }
-      }
-
-      if (result.warnings.length > 0) {
-        return {
-          name: 'Configuration',
-          status: 'degraded',
-          message: `${result.warnings.length} warning(s)`,
-          details: { warnings: result.warnings }
-        }
-      }
-
-      return {
-        name: 'Configuration',
-        status: 'healthy',
-        message: 'Configuration is valid'
-      }
-
-    } catch (error) {
-      return {
-        name: 'Configuration',
-        status: 'unhealthy',
-        message: `Failed to load configuration: ${error}`
-      }
-    }
-  }
-
-  private async checkVault(): Promise<ComponentHealth> {
-    try {
-      const config = await loadConfig()
-      const vault = new VaultManager(config.vaultPath, this.logger, resolveHomePath('./data/backups'))
-
-      await vault.initialize()
-
-      const projects = await vault.reader.getProjectDirectories(vault.paths.projects)
-
-      return {
-        name: 'Vault',
-        status: 'healthy',
-        message: `Found ${projects.length} project(s)`,
-        details: { projectCount: projects.length, projects }
-      }
-
-    } catch (error) {
-      return {
-        name: 'Vault',
-        status: 'unhealthy',
-        message: `Vault check failed: ${error}`
-      }
-    }
-  }
-
-  private async checkMemory(): Promise<ComponentHealth> {
-    try {
-      const config = await loadConfig()
-      const memory = new MemoryManager(config.dbPath, this.logger)
-
-      await memory.initialize()
-
-      const isHealthy = await memory.healthCheck()
-
-      if (!isHealthy) {
-        memory.close()
-        return {
-          name: 'Memory',
-          status: 'unhealthy',
-          message: 'Memory system health check failed'
-        }
-      }
-
-      const stats = memory.getStats()
-
-      memory.close()
-
-      return {
-        name: 'Memory',
-        status: 'healthy',
-        message: 'Memory system operational',
-        details: stats
-      }
-
-    } catch (error) {
-      return {
-        name: 'Memory',
-        status: 'unhealthy',
-        message: `Memory check failed: ${error}`
-      }
-    }
-  }
-
-  private async checkContext(): Promise<ComponentHealth> {
-    try {
-      const config = await loadConfig()
-      const vault = new VaultManager(config.vaultPath, this.logger, resolveHomePath('./data/backups'))
-      await vault.initialize()
-
-      const memory = new MemoryManager(config.dbPath, this.logger)
-      await memory.initialize()
-
-      const context = new ContextManager(this.logger, vault, memory)
-
-      await context.standards.loadGlobalStandards()
-
-      memory.close()
-
-      return {
-        name: 'Context',
-        status: 'healthy',
-        message: 'Context system operational'
-      }
-
-    } catch (error) {
-      return {
-        name: 'Context',
-        status: 'degraded',
-        message: `Context system check: ${error}`
-      }
-    }
-  }
-
-  displayStatus(status: HealthStatus): void {
-    console.log(`\n${this.getStatusEmoji(status.overall)} Overall Status: ${status.overall.toUpperCase()}\n`)
-
-    for (const component of status.components) {
-      const emoji = this.getStatusEmoji(component.status)
-      console.log(`${emoji} ${component.name}: ${component.message}`)
-
-      if (component.details) {
-        console.log(`   ${JSON.stringify(component.details, null, 2)}`)
-      }
-    }
-
-    console.log(`\nChecked at: ${status.timestamp.toLocaleString()}\n`)
-
-    if (status.overall === 'unhealthy') {
-      console.log('⚠️  Some components are unhealthy. Please fix the issues above.\n')
-      process.exit(1)
-    } else if (status.overall === 'degraded') {
-      console.log('⚠️  System is operational but has warnings.\n')
-    } else {
-      console.log('✅ All systems operational!\n')
-    }
-  }
-
-  private getStatusEmoji(status: string): string {
-    switch (status) {
-      case 'healthy': return '✅'
-      case 'degraded': return '⚠️'
-      case 'unhealthy': return '❌'
-      default: return '❓'
-    }
-  }
-}
-
-export async function runHealthCheck() {
-  const logger = createLogger('info', resolveHomePath('./logs/health.log'))
-  const checker = new HealthChecker(logger)
-
-  try {
-    const status = await checker.check()
-    checker.displayStatus(status)
-
-  } catch (error) {
-    console.error('❌ Health check failed:', error)
-    process.exit(1)
-  }
-}
+import { loadConfig } from '@/config'
+import { ConfigValidator } from '@/config/validator'
+import { resolveHomePath } from '@/config/home'
+import { createLogger } from '@/utils/logger'
+import { VaultManager } from '@/vault'
+import { MemoryManager } from '@/memory'
+import { ContextManager } from '@/context'
+
+export interface HealthStatus {
+  overall: 'healthy' | 'degraded' | 'unhealthy'
+  components: ComponentHealth[]
+  timestamp: Date
+}
+
+export interface ComponentHealth {
+  name: string
+  status: 'healthy' | 'degraded' | 'unhealthy'
+  message: string
+  details?: Record<string, any>
+}
+
+export class HealthChecker {
+  private logger: any
+
+  constructor(logger: any) {
+    this.logger = logger.child({ component: 'health-checker' })
+  }
+
+  async check(): Promise<HealthStatus> {
+    console.log('🏥 Running health checks...\n')
+
+    const components: ComponentHealth[] = []
+
+    components.push(await this.checkConfiguration())
+    components.push(await this.checkVault())
+    components.push(await this.checkMemory())
+    components.push(await this.checkContext())
+
+    const hasUnhealthy = components.some(c => c.status === 'unhealthy')
+    const hasDegraded = components.some(c => c.status === 'degraded')
+
+    const overall = hasUnhealthy ? 'unhealthy' : hasDegraded ? 'degraded' : 'healthy'
+
+    return {
+      overall,
+      components,
+      timestamp: new Date()
+    }
+  }
+
+  private async checkConfiguration(): Promise<ComponentHealth> {
+    try {
+      const config = await loadConfig()
+      const validator = new ConfigValidator(this.logger)
+      const result = await validator.validate(config)
+
+      if (!result.valid) {
+        return {
+          name: 'Configuration',
+          status: 'unhealthy',
+          message: `${result.errors.length} configuration error(s)`,
+          details: { errors: result.errors }
+        }
+      }
+
+      if (result.warnings.length > 0) {
+        return {
+          name: 'Configuration',
+          status: 'degraded',
+          message: `${result.warnings.length} warning(s)`,
+          details: { warnings: result.warnings }
+        }
+      }
+
+      return {
+        name: 'Configuration',
+        status: 'healthy',
+        message: 'Configuration is valid'
+      }
+
+    } catch (error) {
+      return {
+        name: 'Configuration',
+        status: 'unhealthy',
+        message: `Failed to load configuration: ${error}`
+      }
+    }
+  }
+
+  private async checkVault(): Promise<ComponentHealth> {
+    try {
+      const config = await loadConfig()
+      const vault = new VaultManager(config.vaultPath, this.logger, resolveHomePath('./data/backups'))
+
+      await vault.initialize()
+
+      const projects = await vault.reader.getProjectDirectories(vault.paths.projects)
+
+      return {
+        name: 'Vault',
+        status: 'healthy',
+        message: `Found ${projects.length} project(s)`,
+        details: { projectCount: projects.length, projects }
+      }
+
+    } catch (error) {
+      return {
+        name: 'Vault',
+        status: 'unhealthy',
+        message: `Vault check failed: ${error}`
+      }
+    }
+  }
+
+  private async checkMemory(): Promise<ComponentHealth> {
+    try {
+      const config = await loadConfig()
+      const memory = new MemoryManager(config.dbPath, this.logger)
+
+      await memory.initialize()
+
+      const isHealthy = await memory.healthCheck()
+
+      if (!isHealthy) {
+        memory.close()
+        return {
+          name: 'Memory',
+          status: 'unhealthy',
+          message: 'Memory system health check failed'
+        }
+      }
+
+      const stats = memory.getStats()
+
+      memory.close()
+
+      return {
+        name: 'Memory',
+        status: 'healthy',
+        message: 'Memory system operational',
+        details: stats
+      }
+
+    } catch (error) {
+      return {
+        name: 'Memory',
+        status: 'unhealthy',
+        message: `Memory check failed: ${error}`
+      }
+    }
+  }
+
+  private async checkContext(): Promise<ComponentHealth> {
+    try {
+      const config = await loadConfig()
+      const vault = new VaultManager(config.vaultPath, this.logger, resolveHomePath('./data/backups'))
+      await vault.initialize()
+
+      const memory = new MemoryManager(config.dbPath, this.logger)
+      await memory.initialize()
+
+      const context = new ContextManager(this.logger, vault, memory)
+
+      await context.standards.loadGlobalStandards()
+
+      memory.close()
+
+      return {
+        name: 'Context',
+        status: 'healthy',
+        message: 'Context system operational'
+      }
+
+    } catch (error) {
+      return {
+        name: 'Context',
+        status: 'degraded',
+        message: `Context system check: ${error}`
+      }
+    }
+  }
+
+  displayStatus(status: HealthStatus): void {
+    console.log(`\n${this.getStatusEmoji(status.overall)} Overall Status: ${status.overall.toUpperCase()}\n`)
+
+    for (const component of status.components) {
+      const emoji = this.getStatusEmoji(component.status)
+      console.log(`${emoji} ${component.name}: ${component.message}`)
+
+      if (component.details) {
+        console.log(`   ${JSON.stringify(component.details, null, 2)}`)
+      }
+    }
+
+    console.log(`\nChecked at: ${status.timestamp.toLocaleString()}\n`)
+
+    if (status.overall === 'unhealthy') {
+      console.log('⚠️  Some components are unhealthy. Please fix the issues above.\n')
+      process.exit(1)
+    } else if (status.overall === 'degraded') {
+      console.log('⚠️  System is operational but has warnings.\n')
+    } else {
+      console.log('✅ All systems operational!\n')
+    }
+  }
+
+  private getStatusEmoji(status: string): string {
+    switch (status) {
+      case 'healthy': return '✅'
+      case 'degraded': return '⚠️'
+      case 'unhealthy': return '❌'
+      default: return '❓'
+    }
+  }
+}
+
+export async function runHealthCheck() {
+  const logger = createLogger('info', resolveHomePath('./logs/health.log'))
+  const checker = new HealthChecker(logger)
+
+  try {
+    const status = await checker.check()
+    checker.displayStatus(status)
+
+  } catch (error) {
+    console.error('❌ Health check failed:', error)
+    process.exit(1)
+  }
+}

package/src/hooks/brain-hook.ts

@@ -1,112 +1,112 @@
-#!/usr/bin/env bun
-/**
- * Phase 17: Brain Hook Worker Script
- * Standalone entry point executed by Claude Code on every tool call.
- *
- * CRITICAL CONSTRAINTS:
- * - Must complete in <200ms (no heavy imports like ChromaDB/embeddings)
- * - NEVER write to stdout (would corrupt Claude Code JSON-RPC)
- * - All errors silently caught with process.exit(0)
- * - Reads stdin JSON from Claude Code, classifies, POSTs to HTTP API
- */
-
-import { BrainCapture } from './capture'
-import { appendToQueue } from './queue'
-import type { HookInput } from './types'
-
-export async function main(): Promise<void> {
-  // Parse --event arg
-  const eventIdx = process.argv.indexOf('--event')
-  const eventName = eventIdx >= 0 ? process.argv[eventIdx + 1] : undefined
-
-  // Read stdin JSON from Claude Code
-  let rawInput: string
-  try {
-    rawInput = await readStdin()
-  } catch {
-    process.exit(0)
-    return
-  }
-
-  if (!rawInput.trim()) {
-    process.exit(0)
-    return
-  }
-
-  let input: HookInput
-  try {
-    input = JSON.parse(rawInput)
-  } catch {
-    process.exit(0)
-    return
-  }
-
-  // Override event name from arg if provided
-  if (eventName) {
-    input.hook_event_name = eventName as HookInput['hook_event_name']
-  }
-
-  // Phase 20: Hooks enabled by default — only disabled by explicit env var
-  if (process.env.CLAUDE_BRAIN_HOOKS_ENABLED === 'false') {
-    process.exit(0)
-    return
-  }
-
-  const port = parseInt(process.env.CLAUDE_BRAIN_PORT || '3000', 10)
-
-  // Process the hook event
-  const capture = new BrainCapture({ enabled: true })
-  const knowledge = capture.process(input)
-
-  if (!knowledge) {
-    process.exit(0)
-    return
-  }
-
-  // POST to HTTP API server
-  try {
-    const res = await fetch(`http://localhost:${port}/api/hooks/ingest`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        knowledge: [knowledge],
-        sessionId: input.session_id,
-      }),
-      signal: AbortSignal.timeout(3000),
-    })
-
-    if (!res.ok) {
-      // Server returned error — queue for later
-      appendToQueue([knowledge])
-    }
-  } catch {
-    // Server unreachable — append to offline queue
-    appendToQueue([knowledge])
-  }
-
-  process.exit(0)
-}
-
-/** Read all of stdin as a string */
-function readStdin(): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const chunks: Buffer[] = []
-    const stdin = process.stdin
-
-    stdin.on('data', (chunk: Buffer) => chunks.push(chunk))
-    stdin.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')))
-    stdin.on('error', reject)
-
-    // Timeout after 2 seconds
-    setTimeout(() => {
-      stdin.destroy()
-      resolve(Buffer.concat(chunks).toString('utf-8'))
-    }, 2000)
-  })
-}
-
-// Execute when run directly (not when imported by CLI)
-const isDirectRun = process.argv[1]?.includes('brain-hook')
-if (isDirectRun) {
-  main().catch(() => process.exit(0))
-}
+#!/usr/bin/env bun
+/**
+ * Phase 17: Brain Hook Worker Script
+ * Standalone entry point executed by Claude Code on every tool call.
+ *
+ * CRITICAL CONSTRAINTS:
+ * - Must complete in <200ms (no heavy imports like ChromaDB/embeddings)
+ * - NEVER write to stdout (would corrupt Claude Code JSON-RPC)
+ * - All errors silently caught with process.exit(0)
+ * - Reads stdin JSON from Claude Code, classifies, POSTs to HTTP API
+ */
+
+import { BrainCapture } from './capture'
+import { appendToQueue } from './queue'
+import type { HookInput } from './types'
+
+export async function main(): Promise<void> {
+  // Parse --event arg
+  const eventIdx = process.argv.indexOf('--event')
+  const eventName = eventIdx >= 0 ? process.argv[eventIdx + 1] : undefined
+
+  // Read stdin JSON from Claude Code
+  let rawInput: string
+  try {
+    rawInput = await readStdin()
+  } catch {
+    process.exit(0)
+    return
+  }
+
+  if (!rawInput.trim()) {
+    process.exit(0)
+    return
+  }
+
+  let input: HookInput
+  try {
+    input = JSON.parse(rawInput)
+  } catch {
+    process.exit(0)
+    return
+  }
+
+  // Override event name from arg if provided
+  if (eventName) {
+    input.hook_event_name = eventName as HookInput['hook_event_name']
+  }
+
+  // Phase 20: Hooks enabled by default — only disabled by explicit env var
+  if (process.env.CLAUDE_BRAIN_HOOKS_ENABLED === 'false') {
+    process.exit(0)
+    return
+  }
+
+  const port = parseInt(process.env.CLAUDE_BRAIN_PORT || '3000', 10)
+
+  // Process the hook event
+  const capture = new BrainCapture({ enabled: true })
+  const knowledge = capture.process(input)
+
+  if (!knowledge) {
+    process.exit(0)
+    return
+  }
+
+  // POST to HTTP API server
+  try {
+    const res = await fetch(`http://localhost:${port}/api/hooks/ingest`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        knowledge: [knowledge],
+        sessionId: input.session_id,
+      }),
+      signal: AbortSignal.timeout(3000),
+    })
+
+    if (!res.ok) {
+      // Server returned error — queue for later
+      appendToQueue([knowledge])
+    }
+  } catch {
+    // Server unreachable — append to offline queue
+    appendToQueue([knowledge])
+  }
+
+  process.exit(0)
+}
+
+/** Read all of stdin as a string */
+function readStdin(): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = []
+    const stdin = process.stdin
+
+    stdin.on('data', (chunk: Buffer) => chunks.push(chunk))
+    stdin.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')))
+    stdin.on('error', reject)
+
+    // Timeout after 2 seconds
+    setTimeout(() => {
+      stdin.destroy()
+      resolve(Buffer.concat(chunks).toString('utf-8'))
+    }, 2000)
+  })
+}
+
+// Execute when run directly (not when imported by CLI)
+const isDirectRun = process.argv[1]?.includes('brain-hook')
+if (isDirectRun) {
+  main().catch(() => process.exit(0))
+}