claude-brain 0.15.2 → 0.16.0

package/src/cli/commands/refresh.ts

@@ -0,0 +1,323 @@
+/**
+ * claude-brain refresh — One-command update & restart.
+ * Kill all instances → install latest → setup ChromaDB/MCP/hooks → verify.
+ * Cross-platform: macOS/Linux and Windows.
+ */
+
+import { execSync } from 'node:child_process'
+import { existsSync, readFileSync, unlinkSync } from 'node:fs'
+import fs from 'fs/promises'
+import path from 'path'
+import os from 'os'
+import { fileURLToPath } from 'url'
+import { getHomePaths } from '@/config/home'
+import { ensureHomeDirectory } from '@/cli/auto-setup'
+import { ensureChromaRunning } from '@/cli/commands/chroma'
+import { installHooks, isHooksInstalled } from '@/hooks/installer'
+import {
+  renderLogo, theme, heading, successText, errorText, warningText, dimText,
+  box, withSpinner,
+} from '@/cli/ui/index.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+const PACKAGE_ROOT = path.resolve(__dirname, '..', '..', '..')
+
+const isWindows = process.platform === 'win32'
+
+function getInstalledVersion(): string {
+  try {
+    const pkg = JSON.parse(readFileSync(path.join(PACKAGE_ROOT, 'package.json'), 'utf-8'))
+    return pkg.version || 'unknown'
+  } catch {
+    return 'unknown'
+  }
+}
+
+function getLatestVersion(): string | null {
+  try {
+    const result = execSync('npm view claude-brain version', {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 15_000,
+    })
+    return result.trim()
+  } catch {
+    return null
+  }
+}
+
+/** Kill processes matching a pattern, excluding our own PID. */
+function killByPattern(pattern: string): boolean {
+  const myPid = process.pid
+  try {
+    if (isWindows) {
+      // Get matching PIDs, filter out ourselves, then kill
+      const result = execSync(
+        `wmic process where "commandline like '%${pattern}%' and processid != ${myPid}" get processid /format:list`,
+        { encoding: 'utf-8', stdio: 'pipe', timeout: 5000 }
+      )
+      const pids = result.match(/ProcessId=(\d+)/g)?.map(m => m.split('=')[1]) || []
+      for (const pid of pids) {
+        try { execSync(`taskkill /F /PID ${pid}`, { stdio: 'pipe', timeout: 5000 }) } catch {}
+      }
+      return pids.length > 0
+    } else {
+      // Get matching PIDs via pgrep, exclude our own, then kill each
+      const result = execSync(`pgrep -f "${pattern}"`, {
+        encoding: 'utf-8', stdio: 'pipe', timeout: 5000,
+      })
+      const pids = result.trim().split('\n').filter(p => p && Number(p) !== myPid)
+      for (const pid of pids) {
+        try { process.kill(Number(pid), 'SIGKILL') } catch {}
+      }
+      return pids.length > 0
+    }
+  } catch {
+    return false
+  }
+}
+
+/** Kill any process listening on a given port, excluding our own PID. */
+function killByPort(port: number): boolean {
+  const myPid = process.pid
+  try {
+    if (isWindows) {
+      const result = execSync(`netstat -ano | findstr :${port} | findstr LISTENING`, {
+        encoding: 'utf-8', stdio: 'pipe', timeout: 5000,
+      })
+      const pids = new Set(
+        result.split('\n')
+          .map(line => line.trim().split(/\s+/).pop())
+          .filter(p => p && Number(p) !== myPid)
+      )
+      for (const pid of pids) {
+        try { execSync(`taskkill /F /PID ${pid}`, { stdio: 'pipe', timeout: 5000 }) } catch {}
+      }
+      return pids.size > 0
+    } else {
+      const raw = execSync(`lsof -ti :${port}`, {
+        encoding: 'utf-8', stdio: 'pipe', timeout: 5000,
+      }).trim()
+      if (raw) {
+        const pids = raw.split('\n').filter(p => p && Number(p) !== myPid)
+        for (const pid of pids) {
+          try { process.kill(Number(pid), 'SIGKILL') } catch {}
+        }
+        return pids.length > 0
+      }
+    }
+  } catch {}
+  return false
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+function isMcpConfigured(): boolean {
+  try {
+    const result = execSync('claude mcp list', {
+      encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 10_000,
+    })
+    return result.includes('claude-brain')
+  } catch {
+    return false
+  }
+}
+
+function registerMcp(): boolean {
+  try {
+    execSync('claude mcp add claude-brain -- claude-brain serve', {
+      encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 10_000,
+    })
+    return true
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err)
+    // Already registered is fine
+    return msg.includes('already') || msg.includes('exists')
+  }
+}
+
+function isChromaReachable(): boolean {
+  for (const apiVersion of ['v2', 'v1']) {
+    try {
+      execSync(`curl -sf http://localhost:8000/api/${apiVersion}/heartbeat`, {
+        stdio: 'pipe', timeout: 3000,
+      })
+      return true
+    } catch {}
+  }
+  return false
+}
+
+// ── Main ──────────────────────────────────────────────────
+
+export async function runRefresh() {
+  console.log()
+  console.log(renderLogo())
+  console.log()
+  console.log(heading('Refresh — Kill, Update, Setup'))
+  console.log()
+
+  const versionBefore = getInstalledVersion()
+  const results: Array<[string, 'ok' | 'warn' | 'fail', string]> = []
+
+  // ── Step 1: Kill all running instances ──────────────────
+
+  await withSpinner('Stopping all claude-brain processes', async () => {
+    // Kill claude-brain processes
+    killByPattern('claude-brain')
+
+    // Kill ChromaDB
+    if (isWindows) {
+      killByPattern('chroma.exe')
+    } else {
+      killByPattern('chroma run')
+    }
+
+    // Kill by port (HTTP API 3333, ChromaDB 8000)
+    killByPort(3333)
+    killByPort(8000)
+
+    // Clean up stale PID file
+    const pidPath = path.join(getHomePaths().data, 'chroma.pid')
+    if (existsSync(pidPath)) {
+      try { unlinkSync(pidPath) } catch {}
+    }
+
+    // Let ports release
+    await sleep(2000)
+  })
+  results.push(['Kill processes', 'ok', 'All instances stopped'])
+  console.log(successText('  All instances stopped'))
+  console.log()
+
+  // ── Step 2: Install latest version ──────────────────────
+
+  const latestVersion = await withSpinner('Checking npm for latest version', async () => getLatestVersion())
+
+  if (latestVersion) {
+    console.log(dimText(`  Installed: v${versionBefore}  →  Latest: v${latestVersion}`))
+  }
+
+  if (latestVersion && latestVersion !== versionBefore) {
+    try {
+      await withSpinner(`Installing claude-brain@${latestVersion}`, async () => {
+        try {
+          execSync('bun install -g claude-brain@latest', {
+            encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 120_000,
+          })
+        } catch {
+          // Fallback to npm
+          execSync('npm install -g claude-brain@latest', {
+            encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 120_000,
+          })
+        }
+      })
+      results.push(['Update', 'ok', `v${versionBefore} → v${latestVersion}`])
+      console.log(successText(`  Updated: v${versionBefore} → v${latestVersion}`))
+    } catch {
+      results.push(['Update', 'fail', 'Install failed — try manually: bun install -g claude-brain@latest'])
+      console.log(warningText('  Update failed. Try manually: bun install -g claude-brain@latest'))
+    }
+  } else {
+    results.push(['Update', 'ok', `v${versionBefore} is latest`])
+    console.log(successText(`  Already on latest (v${versionBefore})`))
+  }
+  console.log()
+
+  // ── Step 3: Full setup ──────────────────────────────────
+
+  // 3a. Home directory
+  await withSpinner('Ensuring home directory', async () => {
+    ensureHomeDirectory()
+  })
+  results.push(['Home dir', 'ok', '~/.claude-brain/'])
+  console.log(successText('  Home directory ready'))
+
+  // 3b. ChromaDB
+  const chromaOk = await withSpinner('Starting ChromaDB', async () => {
+    return ensureChromaRunning({ silent: true })
+  })
+  if (chromaOk) {
+    results.push(['ChromaDB', 'ok', 'Running on port 8000'])
+    console.log(successText('  ChromaDB running'))
+  } else {
+    results.push(['ChromaDB', 'warn', 'Not available — install with: claude-brain chroma install'])
+    console.log(warningText('  ChromaDB not available (install with: claude-brain chroma install)'))
+  }
+
+  // 3c. Hooks
+  await withSpinner('Installing hooks', async () => {
+    installHooks()
+  })
+  const hooksOk = isHooksInstalled()
+  if (hooksOk) {
+    results.push(['Hooks', 'ok', 'Installed in ~/.claude/settings.json'])
+    console.log(successText('  Hooks installed'))
+  } else {
+    results.push(['Hooks', 'warn', 'Hook installation issue'])
+    console.log(warningText('  Hooks may not be fully installed'))
+  }
+
+  // 3d. CLAUDE.md
+  const assetsPath = path.join(PACKAGE_ROOT, 'assets', 'CLAUDE.md')
+  const claudeDir = path.join(os.homedir(), '.claude')
+  const destPath = path.join(claudeDir, 'CLAUDE.md')
+
+  if (existsSync(assetsPath)) {
+    await withSpinner('Updating CLAUDE.md', async () => {
+      await fs.mkdir(claudeDir, { recursive: true })
+      await fs.copyFile(assetsPath, destPath)
+    })
+    results.push(['CLAUDE.md', 'ok', '~/.claude/CLAUDE.md'])
+    console.log(successText('  CLAUDE.md updated'))
+  } else {
+    results.push(['CLAUDE.md', 'warn', 'Asset not found in package'])
+    console.log(warningText('  CLAUDE.md asset not found, skipping'))
+  }
+
+  // 3e. MCP registration
+  const mcpOk = await withSpinner('Checking MCP registration', async () => {
+    if (isMcpConfigured()) return true
+    return registerMcp()
+  })
+  if (mcpOk) {
+    results.push(['MCP', 'ok', 'Registered in Claude Code'])
+    console.log(successText('  MCP server registered'))
+  } else {
+    results.push(['MCP', 'warn', 'Run manually: claude-brain install'])
+    console.log(warningText('  MCP registration failed — run: claude-brain install'))
+  }
+
+  console.log()
+
+  // ── Step 4: Verify & report ─────────────────────────────
+
+  const chromaVerified = isChromaReachable()
+  if (!chromaVerified && chromaOk) {
+    // Update result if it was ok but now unreachable
+    const idx = results.findIndex(r => r[0] === 'ChromaDB')
+    if (idx >= 0) results[idx] = ['ChromaDB', 'warn', 'Started but not responding yet']
+  }
+
+  // Build summary
+  const statusIcon = (s: 'ok' | 'warn' | 'fail') =>
+    s === 'ok' ? successText('✓') : s === 'warn' ? warningText('⚠') : errorText('✗')
+
+  const summaryLines = results.map(
+    ([label, status, detail]) => `  ${statusIcon(status)} ${theme.bold(label!.padEnd(12))} ${dimText(detail!)}`
+  )
+
+  const allOk = results.every(r => r[1] === 'ok')
+
+  console.log(box([
+    heading(allOk ? 'Refresh complete!' : 'Refresh complete (with warnings)'),
+    '',
+    ...summaryLines,
+    '',
+    dimText('Verify: claude-brain health'),
+  ].join('\n'), allOk ? 'Done' : 'Done'))
+  console.log()
+}

package/src/cli/commands/serve.ts

@@ -1,173 +1,167 @@
-import { loadConfig } from '@/config'
-import { createLogger, createComponentLogger } from '@/utils'
-import { GlobalErrorHandler, CleanupManager } from '@/utils'
-import { ClaudeBrainMCPServer } from '@/server'
-import { initializeServices, shutdownServices, getVaultService, getMemoryService } from '@/server/services'
-import { createOrchestrator, type Orchestrator } from '@/orchestrator'
-import { ensureHomeDirectory } from '@/cli/auto-setup'
-import { ensureChromaRunning } from '@/cli/commands/chroma'
-
-const BANNER = `
-╔═══════════════════════════════════════════════════════╗
-║                    CLAUDE BRAIN                        ║
-║     Local Development Assistant with Memory           ║
-╚═══════════════════════════════════════════════════════╝
-`
-
-export async function runServe() {
-  // Auto-initialize home directory on first run
-  ensureHomeDirectory()
-
-  // Background auto-update (non-blocking)
-  try {
-    const { checkForUpdateInBackground } = await import('@/cli/auto-update')
-    checkForUpdateInBackground().catch(() => {})
-  } catch {}
-
-  // Auto-install Claude Code hooks (idempotent, non-fatal)
-  try {
-    const { installHooks } = await import('@/hooks/installer')
-    const hookResult = installHooks()
-    if (hookResult.message !== 'Hooks already installed') {
-      console.error(`[claude-brain] ${hookResult.message}`)
-    }
-  } catch (error) {
-    console.error(`[claude-brain] Hook auto-install skipped: ${error instanceof Error ? error.message : 'unknown error'}`)
-  }
-
-  if (process.env.NODE_ENV !== 'production') {
-    console.error(BANNER)
-  }
-
-  const config = await loadConfig()
-
-  const logger = createLogger(config.logLevel, config.logFilePath)
-  const mainLogger = createComponentLogger(logger, 'main')
-
-  const errorHandler = new GlobalErrorHandler(logger)
-  const cleanup = new CleanupManager(logger)
-
-  mainLogger.info({
-    serverName: config.serverName,
-    serverVersion: config.serverVersion,
-    vaultPath: config.vaultPath,
-    nodeEnv: config.nodeEnv
-  }, 'Claude Brain starting...')
-
-  mainLogger.info({
-    logLevel: config.logLevel,
-    enableFileWatch: config.enableFileWatch,
-    cacheSize: config.cacheSize
-  }, 'Configuration loaded')
-
-  // Auto-start ChromaDB if not already running
-  mainLogger.info('Ensuring ChromaDB is available...')
-  const chromaReady = await ensureChromaRunning({ silent: process.env.NODE_ENV === 'production' })
-  mainLogger.info({ chromaReady }, chromaReady ? 'ChromaDB is ready' : 'ChromaDB not available, using SQLite fallback')
-
-  mainLogger.info('Initializing services...')
-  await initializeServices(config, logger)
-  mainLogger.info('Services initialized successfully')
-
-  // Initialize orchestrator for event-driven features
-  let orchestrator: Orchestrator | null = null
-  try {
-    const vault = getVaultService()
-    const memory = getMemoryService()
-
-    orchestrator = createOrchestrator(logger, vault, memory, {
-      maxConcurrentOperations: 5,
-      debounceMs: 5000
-    })
-
-    await orchestrator.initialize()
-    mainLogger.info('Orchestrator initialized successfully')
-  } catch (error) {
-    mainLogger.warn({ error }, 'Failed to initialize orchestrator, continuing without event-driven features')
-  }
-
-  const mcpServer = new ClaudeBrainMCPServer(config, logger, {
-    events: {
-      onConnectionStateChange: (state) => {
-        mainLogger.info({ state }, 'MCP connection state changed')
-      },
-      onError: (error) => {
-        mainLogger.error({ error: error.message }, 'MCP server error')
-      },
-      onRequest: (toolName, requestId) => {
-        mainLogger.debug({ toolName, requestId }, 'Tool request received')
-      },
-      onResponse: (toolName, requestId, durationMs) => {
-        mainLogger.debug({ toolName, requestId, durationMs }, 'Tool response sent')
-      }
-    }
-  })
-
-  cleanup.register(async () => {
-    await mcpServer.stop()
-  })
-
-  // Register orchestrator cleanup before services shutdown
-  if (orchestrator) {
-    cleanup.register(async () => {
-      orchestrator!.shutdown()
-      mainLogger.info('Orchestrator shut down')
-    })
-  }
-
-  cleanup.register(async () => {
-    await shutdownServices()
-  })
-
-  // Start HTTP API server alongside MCP server
-  const { HttpApiServer } = await import('@/server/http-api')
-  const httpServer = new HttpApiServer(config, logger)
-
-  cleanup.register(async () => {
-    await httpServer.stop()
-  })
-
-  // Phase 21: Use session tracker from services (promoted from local creation)
-  {
-    const { getSessionTracker } = await import('@/server/services')
-    const sessionTracker = getSessionTracker()
-    if (sessionTracker) {
-      httpServer.setSessionTracker(sessionTracker)
-      mainLogger.info('Session tracker wired to HTTP server')
-    }
-  }
-
-  // Start HTTP server after MCP server is ready
-  setTimeout(async () => {
-    try {
-      await httpServer.start()
-      mainLogger.info({ port: config.port }, 'HTTP API server started')
-
-      // Drain hook queue after HTTP server is ready
-      try {
-        const { drainQueue } = await import('@/hooks/queue')
-        const drained = await drainQueue(config.port)
-        if (drained > 0) {
-          mainLogger.info({ drained }, 'Drained hook queue')
-        }
-      } catch (error) {
-        mainLogger.debug({ error }, 'No hook queue to drain')
-      }
-    } catch (error) {
-      mainLogger.error({ error }, 'Failed to start HTTP API server')
-    }
-  }, 2000)
-
-  const shutdown = async (signal: string) => {
-    mainLogger.info({ signal }, 'Shutting down...')
-    await cleanup.cleanup()
-    process.exit(0)
-  }
-
-  process.on('SIGTERM', () => shutdown('SIGTERM'))
-  process.on('SIGINT', () => shutdown('SIGINT'))
-
-  await mcpServer.start()
-
-  mainLogger.info('Claude Brain MCP server ready and listening for connections')
-}
+import { loadConfig } from '@/config'
+import { createLogger, createComponentLogger } from '@/utils'
+import { GlobalErrorHandler, CleanupManager } from '@/utils'
+import { ClaudeBrainMCPServer } from '@/server'
+import { initializeServices, shutdownServices, getVaultService, getMemoryService } from '@/server/services'
+import { createOrchestrator, type Orchestrator } from '@/orchestrator'
+import { ensureHomeDirectory } from '@/cli/auto-setup'
+import { ensureChromaRunning } from '@/cli/commands/chroma'
+
+const BANNER = `
+╔═══════════════════════════════════════════════════════╗
+║                    CLAUDE BRAIN                        ║
+║     Local Development Assistant with Memory           ║
+╚═══════════════════════════════════════════════════════╝
+`
+
+export async function runServe() {
+  // Auto-initialize home directory on first run
+  ensureHomeDirectory()
+
+  // Auto-install Claude Code hooks (idempotent, non-fatal)
+  try {
+    const { installHooks } = await import('@/hooks/installer')
+    const hookResult = installHooks()
+    if (hookResult.message !== 'Hooks already installed') {
+      console.error(`[claude-brain] ${hookResult.message}`)
+    }
+  } catch (error) {
+    console.error(`[claude-brain] Hook auto-install skipped: ${error instanceof Error ? error.message : 'unknown error'}`)
+  }
+
+  if (process.env.NODE_ENV !== 'production') {
+    console.error(BANNER)
+  }
+
+  const config = await loadConfig()
+
+  const logger = createLogger(config.logLevel, config.logFilePath)
+  const mainLogger = createComponentLogger(logger, 'main')
+
+  const errorHandler = new GlobalErrorHandler(logger)
+  const cleanup = new CleanupManager(logger)
+
+  mainLogger.info({
+    serverName: config.serverName,
+    serverVersion: config.serverVersion,
+    vaultPath: config.vaultPath,
+    nodeEnv: config.nodeEnv
+  }, 'Claude Brain starting...')
+
+  mainLogger.info({
+    logLevel: config.logLevel,
+    enableFileWatch: config.enableFileWatch,
+    cacheSize: config.cacheSize
+  }, 'Configuration loaded')
+
+  // Auto-start ChromaDB if not already running
+  mainLogger.info('Ensuring ChromaDB is available...')
+  const chromaReady = await ensureChromaRunning({ silent: process.env.NODE_ENV === 'production' })
+  mainLogger.info({ chromaReady }, chromaReady ? 'ChromaDB is ready' : 'ChromaDB not available, using SQLite fallback')
+
+  mainLogger.info('Initializing services...')
+  await initializeServices(config, logger)
+  mainLogger.info('Services initialized successfully')
+
+  // Initialize orchestrator for event-driven features
+  let orchestrator: Orchestrator | null = null
+  try {
+    const vault = getVaultService()
+    const memory = getMemoryService()
+
+    orchestrator = createOrchestrator(logger, vault, memory, {
+      maxConcurrentOperations: 5,
+      debounceMs: 5000
+    })
+
+    await orchestrator.initialize()
+    mainLogger.info('Orchestrator initialized successfully')
+  } catch (error) {
+    mainLogger.warn({ error }, 'Failed to initialize orchestrator, continuing without event-driven features')
+  }
+
+  const mcpServer = new ClaudeBrainMCPServer(config, logger, {
+    events: {
+      onConnectionStateChange: (state) => {
+        mainLogger.info({ state }, 'MCP connection state changed')
+      },
+      onError: (error) => {
+        mainLogger.error({ error: error.message }, 'MCP server error')
+      },
+      onRequest: (toolName, requestId) => {
+        mainLogger.debug({ toolName, requestId }, 'Tool request received')
+      },
+      onResponse: (toolName, requestId, durationMs) => {
+        mainLogger.debug({ toolName, requestId, durationMs }, 'Tool response sent')
+      }
+    }
+  })
+
+  cleanup.register(async () => {
+    await mcpServer.stop()
+  })
+
+  // Register orchestrator cleanup before services shutdown
+  if (orchestrator) {
+    cleanup.register(async () => {
+      orchestrator!.shutdown()
+      mainLogger.info('Orchestrator shut down')
+    })
+  }
+
+  cleanup.register(async () => {
+    await shutdownServices()
+  })
+
+  // Start HTTP API server alongside MCP server
+  const { HttpApiServer } = await import('@/server/http-api')
+  const httpServer = new HttpApiServer(config, logger)
+
+  cleanup.register(async () => {
+    await httpServer.stop()
+  })
+
+  // Phase 21: Use session tracker from services (promoted from local creation)
+  {
+    const { getSessionTracker } = await import('@/server/services')
+    const sessionTracker = getSessionTracker()
+    if (sessionTracker) {
+      httpServer.setSessionTracker(sessionTracker)
+      mainLogger.info('Session tracker wired to HTTP server')
+    }
+  }
+
+  // Start HTTP server after MCP server is ready
+  setTimeout(async () => {
+    try {
+      await httpServer.start()
+      mainLogger.info({ port: config.port }, 'HTTP API server started')
+
+      // Drain hook queue after HTTP server is ready
+      try {
+        const { drainQueue } = await import('@/hooks/queue')
+        const drained = await drainQueue(config.port)
+        if (drained > 0) {
+          mainLogger.info({ drained }, 'Drained hook queue')
+        }
+      } catch (error) {
+        mainLogger.debug({ error }, 'No hook queue to drain')
+      }
+    } catch (error) {
+      mainLogger.error({ error }, 'Failed to start HTTP API server')
+    }
+  }, 2000)
+
+  const shutdown = async (signal: string) => {
+    mainLogger.info({ signal }, 'Shutting down...')
+    await cleanup.cleanup()
+    process.exit(0)
+  }
+
+  process.on('SIGTERM', () => shutdown('SIGTERM'))
+  process.on('SIGINT', () => shutdown('SIGINT'))
+
+  await mcpServer.start()
+
+  mainLogger.info('Claude Brain MCP server ready and listening for connections')
+}