claude-brain 0.5.1 → 0.9.0

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.1',
+  serverVersion: '0.9.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.1'),
+  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(true),
+
+  /** 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))

package/src/hooks/capture.ts

@@ -0,0 +1,161 @@
+/**
+ * Phase 17: Capture Engine
+ * Orchestrates passive classification + entity extraction with privacy filters.
+ */
+
+import type { HookInput, CapturedKnowledge } from './types'
+import type { HooksConfig } from '@/config/schema'
+import { PassiveClassifier } from './passive-classifier'
+
+// Reuse tech dictionaries from entity extractor for enrichment
+const COMMON_TECH: Set<string> = new Set([
+  'typescript', 'javascript', 'python', 'rust', 'go', 'java', 'ruby', 'php', 'swift', 'kotlin',
+  'react', 'vue', 'angular', 'svelte', 'nextjs', 'nuxt', 'remix', 'astro', 'solid',
+  'express', 'fastify', 'hono', 'nestjs', 'django', 'flask', 'fastapi', 'rails', 'spring',
+  'mongodb', 'redis', 'postgresql', 'postgres', 'mysql', 'sqlite', 'dynamodb', 'firebase', 'supabase',
+  'prisma', 'drizzle', 'typeorm', 'sequelize', 'chromadb', 'pinecone',
+  'docker', 'kubernetes', 'aws', 'gcp', 'azure', 'vercel', 'netlify',
+  'webpack', 'vite', 'esbuild', 'bun', 'deno', 'node', 'npm', 'yarn', 'pnpm',
+  'jest', 'vitest', 'cypress', 'playwright',
+  'tailwind', 'bootstrap', 'zod', 'trpc', 'graphql', 'rest',
+  'jwt', 'oauth', 'openai', 'anthropic', 'langchain',
+  'git', 'github', 'gitlab', 'eslint', 'prettier',
+  'zustand', 'redux', 'pinia', 'mobx', 'jotai', 'recoil',
+  'storybook', 'turborepo', 'nx',
+  'microservices', 'serverless', 'monolith', 'ssr', 'ssg', 'spa', 'pwa', 'mcp', 'rag'
+])
+
+const TECH_ALIASES: Record<string, string> = {
+  'ts': 'typescript', 'js': 'javascript', 'py': 'python',
+  'react.js': 'react', 'reactjs': 'react', 'vue.js': 'vue', 'vuejs': 'vue',
+  'next.js': 'nextjs', 'nuxt.js': 'nuxt', 'nest.js': 'nestjs',
+  'express.js': 'express', 'node.js': 'node', 'nodejs': 'node',
+  'mongo': 'mongodb', 'pg': 'postgresql', 'k8s': 'kubernetes',
+  'tailwindcss': 'tailwind', 'tailwind-css': 'tailwind',
+  'gql': 'graphql', 'golang': 'go',
+}
+
+export class BrainCapture {
+  private classifier: PassiveClassifier
+  private config: HooksConfig
+
+  constructor(config?: Partial<HooksConfig>) {
+    this.config = {
+      enabled: config?.enabled ?? false,
+      capture: {
+        toolUse: config?.capture?.toolUse ?? true,
+        fileEdits: config?.capture?.fileEdits ?? true,
+        bashCommands: config?.capture?.bashCommands ?? true,
+        userMessages: config?.capture?.userMessages ?? true,
+      },
+      privacy: {
+        ignorePaths: config?.privacy?.ignorePaths ?? [],
+        ignoreProjects: config?.privacy?.ignoreProjects ?? [],
+        minConfidence: config?.privacy?.minConfidence ?? 0.7,
+      },
+      sessions: {
+        enabled: config?.sessions?.enabled ?? true,
+        idleTimeoutMinutes: config?.sessions?.idleTimeoutMinutes ?? 30,
+        minEventsForSummary: config?.sessions?.minEventsForSummary ?? 3,
+      },
+      deduplication: {
+        skipThreshold: config?.deduplication?.skipThreshold ?? 0.95,
+        mergeThreshold: config?.deduplication?.mergeThreshold ?? 0.85,
+      },
+    }
+    this.classifier = new PassiveClassifier()
+  }
+
+  /**
+   * Process a hook input event.
+   * Returns captured knowledge or null if nothing worth capturing.
+   */
+  process(input: HookInput): CapturedKnowledge | null {
+    if (!this.config.enabled) return null
+
+    // Privacy: check ignored paths
+    if (this.isPathIgnored(input.cwd)) return null
+
+    // Check capture toggles by tool type
+    if (!this.shouldCapture(input)) return null
+
+    // Classify tool output
+    const knowledge = this.classifier.classify(input)
+    if (!knowledge) return null
+
+    // Privacy: check ignored projects
+    if (knowledge.project && this.config.privacy.ignoreProjects.includes(knowledge.project)) {
+      return null
+    }
+
+    // Enrich with additional technology detection from content
+    knowledge.technologies = this.enrichTechnologies(knowledge)
+
+    // Filter by minimum confidence
+    if (knowledge.confidence < this.config.privacy.minConfidence) {
+      return null
+    }
+
+    return knowledge
+  }
+
+  /** Check if a path matches any ignore pattern */
+  private isPathIgnored(cwd: string): boolean {
+    if (!cwd || this.config.privacy.ignorePaths.length === 0) return false
+    const lowerCwd = cwd.toLowerCase()
+    return this.config.privacy.ignorePaths.some(pattern => {
+      const lowerPattern = pattern.toLowerCase()
+      // Simple glob: just check if pattern appears in path
+      if (lowerPattern.includes('*')) {
+        const regex = new RegExp(lowerPattern.replace(/\*/g, '.*'))
+        return regex.test(lowerCwd)
+      }
+      return lowerCwd.includes(lowerPattern)
+    })
+  }
+
+  /** Check if this tool type should be captured based on config */
+  private shouldCapture(input: HookInput): boolean {
+    const toolName = input.tool_name?.toLowerCase()
+    if (!toolName) return false
+
+    switch (toolName) {
+      case 'edit':
+      case 'write':
+        return this.config.capture.fileEdits
+      case 'bash':
+        return this.config.capture.bashCommands
+      default:
+        return this.config.capture.toolUse
+    }
+  }
+
+  /** Enrich technologies by scanning content text for known tech names */
+  private enrichTechnologies(knowledge: CapturedKnowledge): string[] {
+    const existing = new Set(knowledge.technologies)
+    const lower = knowledge.content.toLowerCase()
+    const words = lower.split(/[\s,;:()[\]{}"'`|/\\]+/)
+
+    for (const word of words) {
+      const cleaned = word.replace(/^[^a-z0-9]+|[^a-z0-9]+$/g, '')
+      if (cleaned.length < 2) continue
+
+      if (COMMON_TECH.has(cleaned) && !existing.has(cleaned)) {
+        existing.add(cleaned)
+      }
+      const alias = TECH_ALIASES[cleaned]
+      if (alias && !existing.has(alias)) {
+        existing.add(alias)
+      }
+    }
+
+    // Check multi-word aliases
+    for (const [alias, normalized] of Object.entries(TECH_ALIASES)) {
+      if ((alias.includes('.') || alias.includes('-')) && lower.includes(alias) && !existing.has(normalized)) {
+        existing.add(normalized)
+      }
+    }
+
+    return Array.from(existing)
+  }
+}