claude-brain 0.9.3 → 0.13.0

package/src/cli/bin.ts

@@ -34,6 +34,9 @@ function printHelp() {
     ['update', 'Update package and refresh CLAUDE.md'],
     ['chroma', 'Manage ChromaDB server (start/stop/status)'],
     ['hooks', 'Manage passive learning hooks (install/uninstall/status)'],
+    ['git-hook', 'Manage git post-commit hook (install/uninstall/status)'],
+    ['init', 'Scan a repo and store initial project context'],
+    ['capture', 'Capture a hook event (used by Claude Code hooks)'],
     ['pack', 'Manage knowledge packs (list/status/reload)'],
     ['health', 'Run health checks'],
     ['diagnose', 'Run diagnostics'],
@@ -124,6 +127,33 @@ async function main() {
       break
     }
 
+    case 'init': {
+      const { runInit } = await import('./commands/init')
+      await runInit()
+      break
+    }
+
+    case 'capture': {
+      // Phase 20: Direct capture command for Claude Code hooks
+      // Usage: claude-brain capture --event=tool_use < /dev/stdin
+      // This is the lightweight path called by the hook script
+      const { main: runCapture } = await import('../hooks/brain-hook')
+      await runCapture()
+      break
+    }
+
+    case 'git-hook': {
+      const { runGitHook } = await import('./commands/git-hook')
+      await runGitHook()
+      break
+    }
+
+    case 'git-capture': {
+      const { handleGitCapture } = await import('../hooks/git-capture')
+      await handleGitCapture()
+      break
+    }
+
     case 'pack': {
       const { runPack } = await import('./commands/pack')
       await runPack()

package/src/cli/commands/git-hook.ts

@@ -0,0 +1,189 @@
+/**
+ * Phase 21: CLI Git Hook Command
+ * Manages git post-commit hook installation (install/uninstall/status)
+ */
+
+import {
+  renderLogo, theme, heading, successText, warningText, errorText, dimText,
+  box, summaryPanel, withSpinner,
+} from '@/cli/ui/index.js'
+import {
+  installGitHook, uninstallGitHook, isGitHookInstalled, installGitHookAll
+} from '@/hooks/git-hook-installer'
+
+export async function runGitHook() {
+  const subcommand = process.argv[3] || 'status'
+
+  switch (subcommand) {
+    case 'install':
+      await handleInstall()
+      break
+    case 'uninstall':
+      await handleUninstall()
+      break
+    case 'status':
+      handleStatus()
+      break
+    default:
+      console.log()
+      console.log(errorText(`Unknown git-hook subcommand: ${subcommand}`))
+      printHelp()
+      process.exit(1)
+  }
+}
+
+async function handleInstall() {
+  console.log()
+  console.log(renderLogo())
+  console.log()
+  console.log(heading('Install Git Hook'))
+  console.log()
+
+  // Check for --all <dir> flag
+  const allIdx = process.argv.indexOf('--all')
+  if (allIdx >= 0) {
+    const dir = process.argv[allIdx + 1]
+    if (!dir) {
+      console.log(errorText('--all requires a directory path'))
+      process.exit(1)
+    }
+
+    let results: { installed: number; skipped: number; errors: number } | undefined
+    await withSpinner(`Installing git hooks in all repos under ${dir}`, async () => {
+      results = await installGitHookAll(dir)
+    })
+
+    console.log()
+    if (results) {
+      console.log(box([
+        successText(`Installed: ${results.installed}`),
+        dimText(`Skipped (already installed): ${results.skipped}`),
+        results.errors > 0 ? warningText(`Errors: ${results.errors}`) : '',
+      ].filter(Boolean).join('\n'), 'Batch Install'))
+    }
+    console.log()
+    return
+  }
+
+  // Single repo install (current directory or specified path)
+  const repoPath = process.argv[4] || undefined
+
+  try {
+    let result: { installed: boolean; message: string; hookPath: string } | undefined
+    await withSpinner('Installing post-commit hook', async () => {
+      result = installGitHook(repoPath)
+    })
+
+    console.log()
+    if (result?.installed) {
+      console.log(box([
+        successText(result.message),
+        '',
+        dimText('The hook fires after every git commit.'),
+        dimText('Commit data (branch, message, files) is sent to brain.'),
+        dimText('The hook runs in the background — no speed impact.'),
+        '',
+        result.hookPath ? `${theme.dim('Hook:')} ${result.hookPath}` : '',
+      ].filter(Boolean).join('\n'), 'Git Hook Installed'))
+    } else if (result) {
+      console.log(box(warningText(result.message), 'Git Hook'))
+    }
+  } catch (err) {
+    console.log()
+    console.log(box(
+      errorText(`Failed: ${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 Git Hook'))
+  console.log()
+
+  const repoPath = process.argv[4] || undefined
+
+  try {
+    let result: { uninstalled: boolean; message: string } | undefined
+    await withSpinner('Removing post-commit hook', async () => {
+      result = uninstallGitHook(repoPath)
+    })
+
+    console.log()
+    if (result?.uninstalled) {
+      console.log(box(successText(result.message), 'Git Hook Removed'))
+    }
+  } catch (err) {
+    console.log()
+    console.log(box(
+      errorText(`Failed: ${err instanceof Error ? err.message : String(err)}`),
+      'Error'
+    ))
+    process.exit(1)
+  }
+  console.log()
+}
+
+function handleStatus() {
+  console.log()
+  console.log(renderLogo())
+  console.log()
+  console.log(heading('Git Hook Status'))
+  console.log()
+
+  const repoPath = process.argv[4] || undefined
+  const installed = isGitHookInstalled(repoPath)
+
+  const items = [
+    {
+      label: 'Installed',
+      value: installed ? 'Yes' : 'No',
+      status: installed ? 'success' as const : 'warning' as const
+    },
+    {
+      label: 'Repo',
+      value: repoPath || process.cwd(),
+      status: 'info' as const
+    },
+    {
+      label: 'Hook type',
+      value: 'post-commit',
+      status: 'info' as const
+    },
+  ]
+
+  console.log(summaryPanel('Git Hook', items))
+  console.log()
+}
+
+function printHelp() {
+  console.log()
+  const commands = [
+    ['install', 'Install post-commit hook in current (or specified) repo'],
+    ['install --all <dir>', 'Install in all git repos under a directory'],
+    ['uninstall', 'Remove post-commit hook from current (or specified) repo'],
+    ['status', 'Check if hook is installed'],
+  ]
+
+  const cmdLines = commands
+    .map(([cmd, desc]) => `  ${theme.primary(cmd!.padEnd(22))} ${dimText(desc!)}`)
+    .join('\n')
+
+  console.log(box([
+    theme.bold('Usage:') + ' ' + dimText('claude-brain git-hook [subcommand]'),
+    '',
+    theme.bold('Subcommands:'),
+    cmdLines,
+    '',
+    theme.bold('Examples:'),
+    `  ${dimText('claude-brain git-hook install')}            ${dimText('Install in current repo')}`,
+    `  ${dimText('claude-brain git-hook install --all ~/dev')} ${dimText('Install in all repos under ~/dev')}`,
+    `  ${dimText('claude-brain git-hook uninstall')}          ${dimText('Remove from current repo')}`,
+  ].join('\n'), 'Git Hook Help'))
+  console.log()
+}

package/src/cli/commands/hooks.ts

@@ -57,15 +57,13 @@ async function handleInstall() {
         '',
         dimText('Hooks will fire on every tool call in Claude Code.'),
         dimText('Knowledge is captured and sent to the brain server.'),
+        dimText('Session summaries are auto-stored when conversations end.'),
         '',
         `${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')}`,
+        dimText('Hooks are enabled by default. To disable:'),
+        `  ${theme.bold('export CLAUDE_BRAIN_HOOKS_ENABLED=false')}`,
       ].join('\n'), 'Hooks Installed'))
     }
   } catch (err) {
@@ -171,12 +169,13 @@ async function handleToggle(enable: boolean) {
   // 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:'),
+      successText('Hooks are enabled by default since v0.10.0.'),
       '',
-      `  ${theme.bold('export CLAUDE_BRAIN_HOOKS_ENABLED=true')}`,
+      dimText('If previously disabled, remove the env variable:'),
+      `  ${theme.bold('unset CLAUDE_BRAIN_HOOKS_ENABLED')}`,
       '',
-      dimText('Or add to your shell profile (.bashrc, .zshrc):'),
-      `  ${dimText('echo \'export CLAUDE_BRAIN_HOOKS_ENABLED=true\' >> ~/.zshrc')}`,
+      dimText('Hooks capture Edit/Write/Bash events automatically.'),
+      dimText('Session summaries are stored when conversations end.'),
     ].join('\n'), 'Enable Hooks'))
   } else {
     console.log(box([

package/src/cli/commands/init.ts

@@ -0,0 +1,98 @@
+/**
+ * Init Command
+ * Phase 22: Scans a repository and stores initial project context.
+ *
+ * Usage: claude-brain init [path] [--force]
+ */
+
+import path from 'path'
+import {
+  renderLogo, theme, heading, successText, warningText, dimText,
+  box, withSpinner,
+} from '@/cli/ui/index.js'
+import { scanRepo } from '@/automation/repo-scanner'
+
+export async function runInit() {
+  console.log()
+  console.log(renderLogo())
+  console.log()
+  console.log(heading('Initialize Project'))
+  console.log()
+
+  // Parse arguments
+  const args = process.argv.slice(3)
+  const force = args.includes('--force')
+  const repoPath = path.resolve(
+    args.find(a => !a.startsWith('--')) || process.cwd()
+  )
+
+  console.log(`  ${theme.bold('Path:')} ${dimText(repoPath)}`)
+  if (force) {
+    console.log(`  ${theme.bold('Mode:')} ${dimText('Force re-scan')}`)
+  }
+  console.log()
+
+  // Scan the repo
+  const context = await withSpinner('Scanning repository', () => scanRepo(repoPath))
+
+  if (!context.name) {
+    console.log(warningText('  Could not detect project name. Specify a path to a project root.'))
+    return
+  }
+
+  // Display results
+  console.log(successText(`  Project: ${context.name}`))
+
+  if (context.techStack.length > 0) {
+    console.log(`  ${theme.bold('Tech stack:')} ${dimText(context.techStack.join(', '))}`)
+  }
+
+  if (context.description) {
+    const desc = context.description.split('\n')[0]?.slice(0, 100) || ''
+    console.log(`  ${theme.bold('Description:')} ${dimText(desc)}`)
+  }
+
+  if (context.recentActivity) {
+    const commits = context.recentActivity.split('\n').length
+    console.log(`  ${theme.bold('Recent commits:')} ${dimText(String(commits))}`)
+  }
+
+  if (context.projectInstructions) {
+    console.log(`  ${theme.bold('CLAUDE.md:')} ${dimText('found')}`)
+  }
+
+  // Try to store context via brain
+  try {
+    const summary = [
+      `Project "${context.name}" initialized.`,
+      context.techStack.length > 0 ? `Tech stack: ${context.techStack.join(', ')}.` : '',
+      context.description ? `Description: ${context.description.split('\n')[0]?.slice(0, 200)}` : '',
+      context.structure ? `Structure:\n${context.structure.split('\n').slice(0, 15).join('\n')}` : '',
+      context.recentActivity ? `Recent git activity:\n${context.recentActivity}` : '',
+      context.projectInstructions ? `CLAUDE.md contents:\n${context.projectInstructions.slice(0, 500)}` : ''
+    ].filter(Boolean).join('\n\n')
+
+    // Write to a local init file so the MCP server can pick it up
+    const { existsSync, mkdirSync } = await import('fs')
+    const { writeFileSync } = await import('fs')
+    const dataDir = path.join(repoPath, '.claude-brain')
+    if (!existsSync(dataDir)) {
+      mkdirSync(dataDir, { recursive: true })
+    }
+    writeFileSync(path.join(dataDir, 'init-context.md'), summary)
+
+    console.log()
+    console.log(successText(`  Initial context saved to .claude-brain/init-context.md`))
+  } catch (error) {
+    console.log(warningText(`  Could not save context: ${error instanceof Error ? error.message : 'unknown error'}`))
+  }
+
+  console.log()
+  console.log(box([
+    heading('Project initialized!'),
+    '',
+    dimText('Brain will auto-load this context in future sessions.'),
+    dimText('Use brain tool to store additional decisions and patterns.'),
+  ].join('\n'), 'Done'))
+  console.log()
+}

package/src/cli/commands/serve.ts

@@ -110,26 +110,13 @@ 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')
+  // 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')
     }
   }
 

package/src/cli/commands/update.ts

@@ -77,11 +77,11 @@ export async function runUpdate() {
   if (!existsSync(sourcePath)) {
     console.log(warningText('  CLAUDE.md asset not found in package, skipping'))
   } else if (!existsSync(destPath)) {
-    await withSpinner('Installing CLAUDE.md', async () => {
+    await withSpinner('Installing CLAUDE.md (brain works automatically)', async () => {
       await fs.mkdir(claudeDir, { recursive: true })
       await fs.copyFile(sourcePath, destPath)
     })
-    console.log(successText('  CLAUDE.md installed to ~/.claude/CLAUDE.md'))
+    console.log(successText('  CLAUDE.md installed to ~/.claude/CLAUDE.md (brain is now automatic)'))
   } else {
     const sourceContent = readFileSync(sourcePath, 'utf-8')
     const destContent = readFileSync(destPath, 'utf-8')
@@ -92,7 +92,7 @@ export async function runUpdate() {
       await withSpinner('Updating CLAUDE.md', async () => {
         await fs.copyFile(sourcePath, destPath)
       })
-      console.log(successText('  CLAUDE.md updated to ~/.claude/CLAUDE.md'))
+      console.log(successText('  CLAUDE.md updated to ~/.claude/CLAUDE.md (brain is now automatic)'))
     }
   }
 

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.9.3',
+  serverVersion: '0.13.0',
   logLevel: 'info',
   logFilePath: './logs/claude-brain.log',
   dbPath: './data/memory.db',
@@ -43,5 +43,8 @@ export const defaultConfig: PartialConfig = {
       adaptiveThresholds: true,
       minFeedbackForAdaptation: 10
     }
+  },
+  intelligence: {
+    enabled: false
   }
 }

package/src/config/schema.ts

@@ -131,10 +131,10 @@ export const KnowledgeConfigSchema = z.object({
 
 export type KnowledgeConfig = z.infer<typeof KnowledgeConfigSchema>
 
-/** Phase 17: Passive Learning via Hooks configuration */
+/** Phase 17+20: Passive Learning via Hooks configuration */
 export const HooksConfigSchema = z.object({
-  /** Master switch for hooks passive learning */
-  enabled: z.boolean().default(false),
+  /** Master switch for hooks passive learning (Phase 20: enabled by default) */
+  enabled: z.boolean().default(true),
 
   /** What to capture from tool calls */
   capture: z.object({
@@ -150,8 +150,22 @@ export const HooksConfigSchema = z.object({
 
   /** Privacy filters */
   privacy: z.object({
-    /** File paths to ignore (glob patterns) */
-    ignorePaths: z.array(z.string()).default([]),
+    /** File paths to ignore (glob patterns) — Phase 20: sensible defaults */
+    ignorePaths: z.array(z.string()).default([
+      'node_modules/**',
+      '.env*',
+      '*.key',
+      '*.pem',
+      '*.p12',
+      '*.pfx',
+      '.git/**',
+      'dist/**',
+      'build/**',
+      '*.secret',
+      'credentials*',
+      '.aws/**',
+      '.ssh/**'
+    ]),
     /** Projects to ignore */
     ignoreProjects: z.array(z.string()).default([]),
     /** Minimum confidence to store captured knowledge */
@@ -270,7 +284,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.9.3'),
+  serverVersion: z.string().regex(/^\d+\.\d+\.\d+$/, 'Version must be semver format').default('0.13.0'),
 
   /** Logging level */
   logLevel: LogLevelSchema.default('info'),
@@ -331,7 +345,13 @@ export const ConfigSchema = z.object({
   hooks: HooksConfigSchema.default({}),
 
   /** Phase 18: Knowledge packs configuration */
-  packs: PacksConfigSchema.default({})
+  packs: PacksConfigSchema.default({}),
+
+  /** Phase 22: Intelligence features (opt-in) */
+  intelligence: z.object({
+    /** Enable consolidated intelligence features */
+    enabled: z.boolean().default(false)
+  }).default({})
 })
 
 export type Config = z.infer<typeof ConfigSchema>

package/src/hooks/brain-hook.ts

@@ -14,7 +14,7 @@ import { BrainCapture } from './capture'
 import { appendToQueue } from './queue'
 import type { HookInput } from './types'
 
-async function main(): Promise<void> {
+export async function main(): Promise<void> {
   // Parse --event arg
   const eventIdx = process.argv.indexOf('--event')
   const eventName = eventIdx >= 0 ? process.argv[eventIdx + 1] : undefined
@@ -46,9 +46,8 @@ async function main(): Promise<void> {
     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) {
+  // Phase 20: Hooks enabled by default — only disabled by explicit env var
+  if (process.env.CLAUDE_BRAIN_HOOKS_ENABLED === 'false') {
     process.exit(0)
     return
   }
@@ -106,5 +105,8 @@ function readStdin(): Promise<string> {
   })
 }
 
-// Execute — all errors caught silently
-main().catch(() => process.exit(0))
+// Execute when run directly (not when imported by CLI)
+const isDirectRun = process.argv[1]?.includes('brain-hook')
+if (isDirectRun) {
+  main().catch(() => process.exit(0))
+}

package/src/hooks/capture.ts

@@ -35,13 +35,20 @@ const TECH_ALIASES: Record<string, string> = {
   'gql': 'graphql', 'golang': 'go',
 }
 
+/** Phase 20: Default privacy ignore paths for sensitive files */
+const DEFAULT_IGNORE_PATHS = [
+  'node_modules/**', '.env*', '*.key', '*.pem', '*.p12', '*.pfx',
+  '.git/**', 'dist/**', 'build/**', '*.secret', 'credentials*',
+  '.aws/**', '.ssh/**'
+]
+
 export class BrainCapture {
   private classifier: PassiveClassifier
   private config: HooksConfig
 
   constructor(config?: Partial<HooksConfig>) {
     this.config = {
-      enabled: config?.enabled ?? false,
+      enabled: config?.enabled ?? true,
       capture: {
         toolUse: config?.capture?.toolUse ?? true,
         fileEdits: config?.capture?.fileEdits ?? true,
@@ -49,7 +56,7 @@ export class BrainCapture {
         userMessages: config?.capture?.userMessages ?? true,
       },
       privacy: {
-        ignorePaths: config?.privacy?.ignorePaths ?? [],
+        ignorePaths: config?.privacy?.ignorePaths ?? DEFAULT_IGNORE_PATHS,
         ignoreProjects: config?.privacy?.ignoreProjects ?? [],
         minConfidence: config?.privacy?.minConfidence ?? 0.7,
       },

package/src/hooks/git-capture.ts

@@ -0,0 +1,94 @@
+/**
+ * Phase 21: Git Commit Capture
+ * Receives commit data from the post-commit hook and sends it to brain.
+ * Called as: claude-brain git-capture <project> <branch> <message> <files> <port>
+ */
+
+import { appendToQueue } from './queue'
+import type { CapturedKnowledge } from './types'
+
+export async function handleGitCapture(): Promise<void> {
+  // Parse positional args: project, branch, message, files, port
+  const [, , , project, branch, message, filesStr, portStr] = process.argv
+
+  if (!project || !message) {
+    process.exit(0)
+    return
+  }
+
+  const port = parseInt(portStr || process.env.CLAUDE_BRAIN_PORT || '3000', 10)
+  const files = filesStr ? filesStr.split(',').filter(Boolean) : []
+
+  // Build captured knowledge
+  const knowledge: CapturedKnowledge = {
+    type: 'progress',
+    confidence: 0.9,
+    content: `Git commit on ${branch || 'unknown'}: ${message.trim()}${files.length > 0 ? ` (files: ${files.join(', ')})` : ''}`,
+    project: project || undefined,
+    technologies: detectTechnologies(files),
+    metadata: {
+      source: 'git-hook',
+      branch: branch || 'unknown',
+      commit_message: message.trim(),
+      files,
+      file_count: files.length,
+    },
+    source: 'hook-passive',
+    timestamp: new Date().toISOString(),
+  }
+
+  // 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: `git-${project}-${Date.now()}`,
+      }),
+      signal: AbortSignal.timeout(3000),
+    })
+
+    if (!res.ok) {
+      appendToQueue([knowledge])
+    }
+  } catch {
+    // Server unreachable — queue for later
+    appendToQueue([knowledge])
+  }
+
+  process.exit(0)
+}
+
+/**
+ * Detect technologies from file extensions.
+ */
+function detectTechnologies(files: string[]): string[] {
+  const techMap: Record<string, string> = {
+    '.ts': 'typescript',
+    '.tsx': 'react',
+    '.js': 'javascript',
+    '.jsx': 'react',
+    '.py': 'python',
+    '.rs': 'rust',
+    '.go': 'go',
+    '.rb': 'ruby',
+    '.java': 'java',
+    '.swift': 'swift',
+    '.kt': 'kotlin',
+    '.vue': 'vue',
+    '.svelte': 'svelte',
+    '.css': 'css',
+    '.scss': 'scss',
+    '.sql': 'sql',
+  }
+
+  const techs = new Set<string>()
+  for (const file of files) {
+    const ext = '.' + file.split('.').pop()
+    if (techMap[ext]) {
+      techs.add(techMap[ext])
+    }
+  }
+  return [...techs]
+}