claude-brain 0.5.0 → 0.8.0

package/src/cli/commands/hooks.ts

@@ -0,0 +1,214 @@
+/**
+ * Phase 17: CLI Hooks Command
+ * Manages passive learning hooks (install/uninstall/status/enable/disable)
+ */
+
+import {
+  renderLogo, theme, heading, successText, warningText, errorText, dimText,
+  box, summaryPanel, withSpinner,
+} from '@/cli/ui/index.js'
+import { installHooks, uninstallHooks, isHooksInstalled, getHookScriptPath } from '@/hooks/installer'
+import { readQueue } from '@/hooks/queue'
+
+export async function runHooks() {
+  const subcommand = process.argv[3] || 'status'
+
+  switch (subcommand) {
+    case 'install':
+      await handleInstall()
+      break
+    case 'uninstall':
+      await handleUninstall()
+      break
+    case 'status':
+      await handleStatus()
+      break
+    case 'enable':
+      await handleToggle(true)
+      break
+    case 'disable':
+      await handleToggle(false)
+      break
+    default:
+      console.log()
+      console.log(errorText(`Unknown hooks subcommand: ${subcommand}`))
+      printHooksHelp()
+      process.exit(1)
+  }
+}
+
+async function handleInstall() {
+  console.log()
+  console.log(renderLogo())
+  console.log()
+  console.log(heading('Install Passive Learning Hooks'))
+  console.log()
+
+  try {
+    let result: { installed: boolean; message: string } | undefined
+    await withSpinner('Installing hooks into Claude Code', async () => {
+      result = installHooks()
+    })
+
+    console.log()
+    if (result?.installed) {
+      console.log(box([
+        successText(result.message),
+        '',
+        dimText('Hooks will fire on every tool call in Claude Code.'),
+        dimText('Knowledge is captured and sent to the brain server.'),
+        '',
+        `${theme.dim('Hook script:')} ${getHookScriptPath()}`,
+        `${theme.dim('Settings:')}    ~/.claude/settings.json`,
+        '',
+        dimText('Enable passive learning:'),
+        `  ${theme.bold('CLAUDE_BRAIN_HOOKS_ENABLED=true')}`,
+        '',
+        dimText('Or enable in config:'),
+        `  ${theme.bold('hooks.enabled: true')} ${dimText('in ~/.claude-brain/.env')}`,
+      ].join('\n'), 'Hooks Installed'))
+    }
+  } catch (err) {
+    console.log()
+    console.log(box(
+      errorText(`Failed to install hooks: ${err instanceof Error ? err.message : String(err)}`),
+      'Error'
+    ))
+    process.exit(1)
+  }
+  console.log()
+}
+
+async function handleUninstall() {
+  console.log()
+  console.log(renderLogo())
+  console.log()
+  console.log(heading('Uninstall Passive Learning Hooks'))
+  console.log()
+
+  try {
+    let result: { uninstalled: boolean; message: string } | undefined
+    await withSpinner('Removing hooks from Claude Code', async () => {
+      result = uninstallHooks()
+    })
+
+    console.log()
+    if (result?.uninstalled) {
+      console.log(box(
+        successText(result.message),
+        'Hooks Removed'
+      ))
+    }
+  } catch (err) {
+    console.log()
+    console.log(box(
+      errorText(`Failed to uninstall hooks: ${err instanceof Error ? err.message : String(err)}`),
+      'Error'
+    ))
+    process.exit(1)
+  }
+  console.log()
+}
+
+async function handleStatus() {
+  console.log()
+  console.log(renderLogo())
+  console.log()
+  console.log(heading('Hook Status'))
+  console.log()
+
+  const installed = isHooksInstalled()
+  const queueItems = readQueue()
+  const envEnabled = process.env.CLAUDE_BRAIN_HOOKS_ENABLED !== 'false'
+
+  const items = [
+    { label: 'Installed', value: installed ? 'Yes' : 'No', status: installed ? 'success' as const : 'warning' as const },
+    { label: 'Env enabled', value: envEnabled ? 'Yes' : 'No', status: envEnabled ? 'success' as const : 'info' as const },
+    { label: 'Queue items', value: String(queueItems.length), status: queueItems.length > 0 ? 'warning' as const : 'info' as const },
+    { label: 'Hook script', value: getHookScriptPath(), status: 'info' as const },
+  ]
+
+  console.log(summaryPanel('Passive Learning Hooks', items))
+
+  // Try to fetch live stats from the server
+  try {
+    const port = parseInt(process.env.CLAUDE_BRAIN_PORT || '3000', 10)
+    const res = await fetch(`http://localhost:${port}/api/hooks/status`, {
+      signal: AbortSignal.timeout(2000),
+    })
+
+    if (res.ok) {
+      const data = await res.json() as any
+      if (data.success && data.data) {
+        console.log()
+        const serverItems = [
+          { label: 'Total captured', value: String(data.data.totalCaptured || 0), status: 'info' as const },
+          { label: 'Total skipped', value: String(data.data.totalSkipped || 0), status: 'info' as const },
+          { label: 'Total merged', value: String(data.data.totalMerged || 0), status: 'info' as const },
+          { label: 'Active sessions', value: String(data.data.activeSessions || 0), status: 'info' as const },
+          { label: 'Last capture', value: data.data.lastCaptureAt || 'Never', status: 'info' as const },
+        ]
+        console.log(summaryPanel('Server Stats', serverItems))
+      }
+    }
+  } catch {
+    console.log()
+    console.log(dimText('  (Server not running — no live stats available)'))
+  }
+
+  console.log()
+}
+
+async function handleToggle(enable: boolean) {
+  console.log()
+  console.log(renderLogo())
+  console.log()
+
+  const action = enable ? 'Enabling' : 'Disabling'
+  console.log(heading(`${action} Passive Learning`))
+  console.log()
+
+  // Toggle via env hint (actual config toggle would need config file editing)
+  if (enable) {
+    console.log(box([
+      successText('To enable hooks, set the environment variable:'),
+      '',
+      `  ${theme.bold('export CLAUDE_BRAIN_HOOKS_ENABLED=true')}`,
+      '',
+      dimText('Or add to your shell profile (.bashrc, .zshrc):'),
+      `  ${dimText('echo \'export CLAUDE_BRAIN_HOOKS_ENABLED=true\' >> ~/.zshrc')}`,
+    ].join('\n'), 'Enable Hooks'))
+  } else {
+    console.log(box([
+      warningText('To disable hooks, set the environment variable:'),
+      '',
+      `  ${theme.bold('export CLAUDE_BRAIN_HOOKS_ENABLED=false')}`,
+      '',
+      dimText('This stops hook processing without uninstalling.'),
+    ].join('\n'), 'Disable Hooks'))
+  }
+  console.log()
+}
+
+function printHooksHelp() {
+  console.log()
+  const commands = [
+    ['install', 'Install hooks into Claude Code settings'],
+    ['uninstall', 'Remove hooks from Claude Code settings'],
+    ['status', 'Show hook installation and capture stats'],
+    ['enable', 'Enable passive learning (show instructions)'],
+    ['disable', 'Disable passive learning (show instructions)'],
+  ]
+
+  const cmdLines = commands
+    .map(([cmd, desc]) => `  ${theme.primary(cmd!.padEnd(14))} ${dimText(desc!)}`)
+    .join('\n')
+
+  console.log(box([
+    theme.bold('Usage:') + ' ' + dimText('claude-brain hooks [subcommand]'),
+    '',
+    theme.bold('Subcommands:'),
+    cmdLines,
+  ].join('\n'), 'Hooks Help'))
+  console.log()
+}

package/src/cli/commands/pack.ts

@@ -0,0 +1,197 @@
+/**
+ * Phase 18: CLI Pack Command
+ * Manages knowledge packs (list/status/reload)
+ */
+
+import {
+  renderLogo, theme, heading, successText, warningText, errorText, dimText,
+  box, summaryPanel, withSpinner,
+} from '@/cli/ui/index.js'
+import { readFileSync } from 'node:fs'
+import { resolve, dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { PackManager } from '@/packs/manager'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const PACKAGE_ROOT = resolve(__dirname, '..', '..', '..')
+
+function getDataDir(): string {
+  return join(
+    process.env.CLAUDE_BRAIN_HOME || join(process.env.HOME || '~', '.claude-brain'),
+    'data'
+  )
+}
+
+function getDefaultConfig() {
+  return {
+    enabled: true,
+    packsDir: 'packs',
+    alwaysLoadCore: true,
+    alwaysLoadMeta: true,
+    communityConfidenceMultiplier: 0.8,
+    personalBoost: 1.2,
+    projectBoost: 1.15
+  }
+}
+
+function createPackManager(): PackManager {
+  // Lightweight logger for CLI
+  const logger = {
+    child: () => logger,
+    debug: () => {},
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+  } as any
+
+  return new PackManager(logger, getDefaultConfig(), PACKAGE_ROOT, getDataDir())
+}
+
+export async function runPack() {
+  const subcommand = process.argv[3] || 'list'
+
+  switch (subcommand) {
+    case 'list':
+      await handleList()
+      break
+    case 'status':
+      await handleStatus()
+      break
+    case 'reload':
+      await handleReload()
+      break
+    default:
+      console.log()
+      console.log(errorText(`Unknown pack subcommand: ${subcommand}`))
+      printPackHelp()
+      process.exit(1)
+  }
+}
+
+async function handleList() {
+  console.log()
+  console.log(renderLogo())
+  console.log()
+  console.log(heading('Available Knowledge Packs'))
+  console.log()
+
+  const manager = createPackManager()
+
+  let packs: Array<{ id: string; name: string; description: string; entries: number; version: string }> = []
+  await withSpinner('Scanning packs directory', async () => {
+    packs = await manager.listAvailablePacks()
+  })
+
+  if (packs.length === 0) {
+    console.log(warningText('  No packs found in packs/ directory'))
+    console.log()
+    return
+  }
+
+  console.log()
+  for (const pack of packs) {
+    console.log(`  ${theme.primary(pack.id.padEnd(24))} ${theme.bold(pack.name)}`)
+    console.log(`  ${''.padEnd(24)} ${dimText(pack.description)}`)
+    console.log(`  ${''.padEnd(24)} ${dimText(`v${pack.version} - ${pack.entries} entries`)}`)
+    console.log()
+  }
+
+  const totalEntries = packs.reduce((sum, p) => sum + p.entries, 0)
+  console.log(dimText(`  Total: ${packs.length} packs, ${totalEntries} entries`))
+  console.log()
+}
+
+async function handleStatus() {
+  console.log()
+  console.log(renderLogo())
+  console.log()
+  console.log(heading('Pack Status'))
+  console.log()
+
+  const project = process.argv[4]
+  if (!project) {
+    console.log(warningText('  Usage: claude-brain pack status <project-name>'))
+    console.log(dimText('  Example: claude-brain pack status my-app'))
+    console.log()
+    return
+  }
+
+  const manager = createPackManager()
+  const manifest = await manager.getManifest(project)
+
+  if (manifest.packs.length === 0) {
+    console.log(dimText(`  No packs loaded for project "${project}"`))
+    console.log(dimText('  Packs are loaded automatically when you run init_project'))
+    console.log()
+    return
+  }
+
+  const items = manifest.packs.map(p => ({
+    label: p.packId,
+    value: `v${p.version} (${p.entriesLoaded} entries, ${new Date(p.loadedAt).toLocaleDateString()})`,
+    status: 'success' as const
+  }))
+
+  console.log(summaryPanel(`Packs for ${project}`, items))
+  console.log()
+  console.log(dimText(`  Last updated: ${manifest.lastUpdated}`))
+  console.log()
+}
+
+async function handleReload() {
+  console.log()
+  console.log(renderLogo())
+  console.log()
+  console.log(heading('Reload Knowledge Packs'))
+  console.log()
+
+  const project = process.argv[4]
+  if (!project) {
+    console.log(warningText('  Usage: claude-brain pack reload <project-name>'))
+    console.log(dimText('  This clears the manifest so packs are re-loaded on next init_project'))
+    console.log()
+    return
+  }
+
+  const manager = createPackManager()
+
+  await withSpinner(`Clearing manifest for "${project}"`, async () => {
+    await manager.deleteManifest(project)
+  })
+
+  console.log()
+  console.log(box([
+    successText(`Manifest cleared for "${project}"`),
+    '',
+    dimText('Packs will be re-loaded on the next init_project call.'),
+    dimText('Or use the init_project MCP tool to reload now.'),
+  ].join('\n'), 'Reload'))
+  console.log()
+}
+
+function printPackHelp() {
+  console.log()
+  const commands = [
+    ['list', 'Show all available knowledge packs'],
+    ['status', 'Show loaded packs for a project'],
+    ['reload', 'Clear manifest to force pack reload'],
+  ]
+
+  const cmdLines = commands
+    .map(([cmd, desc]) => `  ${theme.primary(cmd!.padEnd(14))} ${dimText(desc!)}`)
+    .join('\n')
+
+  console.log(box([
+    theme.bold('Usage:') + ' ' + dimText('claude-brain pack [subcommand]'),
+    '',
+    theme.bold('Subcommands:'),
+    cmdLines,
+    '',
+    theme.bold('Examples:'),
+    `  ${dimText('claude-brain pack list')}`,
+    `  ${dimText('claude-brain pack status my-project')}`,
+    `  ${dimText('claude-brain pack reload my-project')}`,
+  ].join('\n'), 'Pack Help'))
+  console.log()
+}

package/src/cli/commands/serve.ts

@@ -110,11 +110,45 @@ export async function runServe() {
     await httpServer.stop()
   })
 
+  // Phase 17: Initialize hook session tracker + queue drain
+  let hookSessionTracker: any = null
+  if (config.hooks?.enabled !== false) {
+    try {
+      const { HookSessionTracker } = await import('@/hooks/session-tracker')
+      const { getEpisodeService } = await import('@/server/services')
+      const episodeManager = getEpisodeService()
+      hookSessionTracker = new HookSessionTracker(logger, episodeManager, config.hooks?.sessions)
+      httpServer.setSessionTracker(hookSessionTracker)
+
+      cleanup.register(async () => {
+        if (hookSessionTracker) {
+          await hookSessionTracker.endAllSessions()
+          mainLogger.info('Hook session tracker shut down')
+        }
+      })
+
+      mainLogger.info('Hook session tracker initialized')
+    } catch (error) {
+      mainLogger.warn({ error }, 'Failed to initialize hook session tracker, continuing without passive learning')
+    }
+  }
+
   // 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')
     }

package/src/config/defaults.ts

@@ -3,7 +3,7 @@ import type { PartialConfig } from './schema'
 /** Default configuration values for Claude Brain */
 export const defaultConfig: PartialConfig = {
   serverName: 'claude-brain',
-  serverVersion: '0.5.0',
+  serverVersion: '0.8.0',
   logLevel: 'info',
   logFilePath: './logs/claude-brain.log',
   dbPath: './data/memory.db',

package/src/config/schema.ts

@@ -131,6 +131,80 @@ export const KnowledgeConfigSchema = z.object({
 
 export type KnowledgeConfig = z.infer<typeof KnowledgeConfigSchema>
 
+/** Phase 17: Passive Learning via Hooks configuration */
+export const HooksConfigSchema = z.object({
+  /** Master switch for hooks passive learning */
+  enabled: z.boolean().default(false),
+
+  /** What to capture from tool calls */
+  capture: z.object({
+    /** Capture knowledge from tool use (Edit/Write) */
+    toolUse: z.boolean().default(true),
+    /** Capture knowledge from file edits */
+    fileEdits: z.boolean().default(true),
+    /** Capture knowledge from bash commands */
+    bashCommands: z.boolean().default(true),
+    /** Capture knowledge from user messages */
+    userMessages: z.boolean().default(true)
+  }).default({}),
+
+  /** Privacy filters */
+  privacy: z.object({
+    /** File paths to ignore (glob patterns) */
+    ignorePaths: z.array(z.string()).default([]),
+    /** Projects to ignore */
+    ignoreProjects: z.array(z.string()).default([]),
+    /** Minimum confidence to store captured knowledge */
+    minConfidence: z.number().min(0).max(1).default(0.7)
+  }).default({}),
+
+  /** Session tracking settings */
+  sessions: z.object({
+    /** Enable session tracking */
+    enabled: z.boolean().default(true),
+    /** Idle timeout in minutes before summarizing */
+    idleTimeoutMinutes: z.number().int().min(1).default(30),
+    /** Minimum events required before generating summary */
+    minEventsForSummary: z.number().int().min(1).default(3)
+  }).default({}),
+
+  /** Deduplication thresholds */
+  deduplication: z.object({
+    /** Similarity above this skips storage (exact duplicate) */
+    skipThreshold: z.number().min(0).max(1).default(0.95),
+    /** Similarity above this merges instead of creating new */
+    mergeThreshold: z.number().min(0).max(1).default(0.85)
+  }).default({})
+})
+
+export type HooksConfig = z.infer<typeof HooksConfigSchema>
+
+/** Phase 18: Knowledge Packs configuration */
+export const PacksConfigSchema = z.object({
+  /** Master switch for knowledge packs */
+  enabled: z.boolean().default(true),
+
+  /** Directory name for pack files (relative to package root) */
+  packsDir: z.string().default('packs'),
+
+  /** Always load core/ packs regardless of tech stack */
+  alwaysLoadCore: z.boolean().default(true),
+
+  /** Always load meta/ packs regardless of tech stack */
+  alwaysLoadMeta: z.boolean().default(true),
+
+  /** Confidence multiplier for community (pack) entries (dampens scores) */
+  communityConfidenceMultiplier: z.number().min(0).max(1).default(0.8),
+
+  /** Search result boost for personal (user-created) entries */
+  personalBoost: z.number().min(1).max(2).default(1.2),
+
+  /** Search result boost for project-specific entries */
+  projectBoost: z.number().min(1).max(2).default(1.15)
+})
+
+export type PacksConfig = z.infer<typeof PacksConfigSchema>
+
 /** Phase 15: Advanced Intelligence configuration */
 export const AdvancedIntelligenceConfigSchema = z.object({
   /** Enable advanced intelligence features (Phase 15) */
@@ -196,7 +270,7 @@ export const ConfigSchema = z.object({
   serverName: z.string().default('claude-brain'),
 
   /** Server version in semver format */
-  serverVersion: z.string().regex(/^\d+\.\d+\.\d+$/, 'Version must be semver format').default('0.5.0'),
+  serverVersion: z.string().regex(/^\d+\.\d+\.\d+$/, 'Version must be semver format').default('0.8.0'),
 
   /** Logging level */
   logLevel: LogLevelSchema.default('info'),
@@ -248,7 +322,16 @@ export const ConfigSchema = z.object({
   knowledge: KnowledgeConfigSchema.default({}),
 
   /** Advanced intelligence configuration (Phase 15) */
-  advancedIntelligence: AdvancedIntelligenceConfigSchema.default({})
+  advancedIntelligence: AdvancedIntelligenceConfigSchema.default({}),
+
+  /** Phase 16: Unified tool mode — expose only brain() instead of all 25 tools */
+  unifiedToolMode: z.boolean().default(false),
+
+  /** Phase 17: Passive learning hooks configuration */
+  hooks: HooksConfigSchema.default({}),
+
+  /** Phase 18: Knowledge packs configuration */
+  packs: PacksConfigSchema.default({})
 })
 
 export type Config = z.infer<typeof ConfigSchema>

package/src/hooks/brain-hook.ts

@@ -0,0 +1,110 @@
+#!/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'
+
+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']
+  }
+
+  // Load minimal config from env vars
+  const enabled = process.env.CLAUDE_BRAIN_HOOKS_ENABLED !== 'false'
+  if (!enabled) {
+    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 — all errors caught silently
+main().catch(() => process.exit(0))