claude-brain 0.9.3 → 0.13.0

package/src/hooks/git-hook-installer.ts

@@ -0,0 +1,197 @@
+/**
+ * Phase 21: Git Hook Installer
+ * Installs/uninstalls a post-commit git hook that captures commit data into brain.
+ */
+
+import {
+  readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync, unlinkSync, readdirSync
+} from 'node:fs'
+import { join, resolve } from 'node:path'
+import { execSync } from 'node:child_process'
+
+const HOOK_MARKER = '# claude-brain-git-hook'
+const HOOK_FILENAME = 'post-commit'
+
+/**
+ * Build the hook script content that gets appended to .git/hooks/post-commit.
+ * Runs in background (&) so it doesn't slow down git.
+ */
+function buildHookScript(): string {
+  const lines = [
+    '',
+    HOOK_MARKER,
+    '# Capture commit data into Claude Brain (runs in background)',
+    '(',
+    '  BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null)',
+    '  MESSAGE=$(git log -1 --pretty=%B 2>/dev/null)',
+    '  FILES=$(git diff-tree --no-commit-id --name-only -r HEAD 2>/dev/null | tr "\\n" "," | sed "s/,$//")',
+    '  PROJECT=$(basename "$(git rev-parse --show-toplevel 2>/dev/null)")',
+    '  PORT=${CLAUDE_BRAIN_PORT:-3000}',
+    '  claude-brain git-capture "$PROJECT" "$BRANCH" "$MESSAGE" "$FILES" "$PORT" 2>/dev/null',
+    ') &',
+    `${HOOK_MARKER}-end`,
+    '',
+  ]
+  return lines.join('\n')
+}
+
+/**
+ * Find the .git directory for a given path.
+ * Returns null if not in a git repo.
+ */
+function findGitDir(repoPath?: string): string | null {
+  const cwd = repoPath ? resolve(repoPath) : process.cwd()
+  try {
+    const gitDir = execSync('git rev-parse --git-dir', {
+      cwd,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim()
+    // git-dir can be relative; resolve against cwd
+    return resolve(cwd, gitDir)
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Install the post-commit hook into a git repository.
+ * Appends to existing hook if one exists; creates new if not.
+ */
+export function installGitHook(repoPath?: string): { installed: boolean; message: string; hookPath: string } {
+  const gitDir = findGitDir(repoPath)
+  if (!gitDir) {
+    return { installed: false, message: 'Not a git repository', hookPath: '' }
+  }
+
+  const hooksDir = join(gitDir, 'hooks')
+  const hookPath = join(hooksDir, HOOK_FILENAME)
+
+  // Already installed?
+  if (isGitHookInstalled(repoPath)) {
+    return { installed: true, message: 'Git hook already installed', hookPath }
+  }
+
+  // Ensure hooks dir exists
+  if (!existsSync(hooksDir)) {
+    mkdirSync(hooksDir, { recursive: true })
+  }
+
+  // Read existing hook or start fresh
+  let existing = ''
+  if (existsSync(hookPath)) {
+    existing = readFileSync(hookPath, 'utf-8')
+  } else {
+    existing = '#!/bin/sh\n'
+  }
+
+  // Append our section
+  const combined = existing.trimEnd() + '\n' + buildHookScript()
+  writeFileSync(hookPath, combined, 'utf-8')
+  chmodSync(hookPath, 0o755)
+
+  return { installed: true, message: 'Git hook installed successfully', hookPath }
+}
+
+/**
+ * Uninstall the post-commit hook from a git repository.
+ * Removes only our section, preserving the rest.
+ */
+export function uninstallGitHook(repoPath?: string): { uninstalled: boolean; message: string } {
+  const gitDir = findGitDir(repoPath)
+  if (!gitDir) {
+    return { uninstalled: false, message: 'Not a git repository' }
+  }
+
+  const hookPath = join(gitDir, 'hooks', HOOK_FILENAME)
+
+  if (!existsSync(hookPath)) {
+    return { uninstalled: true, message: 'No post-commit hook found' }
+  }
+
+  const content = readFileSync(hookPath, 'utf-8')
+  if (!content.includes(HOOK_MARKER)) {
+    return { uninstalled: true, message: 'Claude Brain hook not found in post-commit' }
+  }
+
+  // Remove our section (from marker to end-marker)
+  const lines = content.split('\n')
+  const filtered: string[] = []
+  let inOurSection = false
+
+  for (const line of lines) {
+    if (line.trim() === HOOK_MARKER) {
+      inOurSection = true
+      continue
+    }
+    if (line.trim() === `${HOOK_MARKER}-end`) {
+      inOurSection = false
+      continue
+    }
+    if (!inOurSection) {
+      filtered.push(line)
+    }
+  }
+
+  const cleaned = filtered.join('\n').trimEnd() + '\n'
+
+  // If only shebang remains, remove the hook file entirely
+  if (cleaned.trim() === '#!/bin/sh' || cleaned.trim() === '#!/bin/bash' || cleaned.trim() === '') {
+    unlinkSync(hookPath)
+    return { uninstalled: true, message: 'Git hook removed (file deleted — was empty)' }
+  }
+
+  writeFileSync(hookPath, cleaned, 'utf-8')
+  return { uninstalled: true, message: 'Git hook removed successfully' }
+}
+
+/**
+ * Check if our hook is installed in a git repository.
+ */
+export function isGitHookInstalled(repoPath?: string): boolean {
+  const gitDir = findGitDir(repoPath)
+  if (!gitDir) return false
+
+  const hookPath = join(gitDir, 'hooks', HOOK_FILENAME)
+  if (!existsSync(hookPath)) return false
+
+  const content = readFileSync(hookPath, 'utf-8')
+  return content.includes(HOOK_MARKER)
+}
+
+/**
+ * Scan a directory for git repos and install hooks in all of them.
+ */
+export async function installGitHookAll(dir: string): Promise<{ installed: number; skipped: number; errors: number }> {
+  const results = { installed: 0, skipped: 0, errors: 0 }
+  const absDir = resolve(dir)
+
+  if (!existsSync(absDir)) {
+    return results
+  }
+
+  // Find directories with .git
+  const entries = readdirSync(absDir, { withFileTypes: true })
+
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith('.')) continue
+
+    const candidatePath = join(absDir, entry.name)
+    const gitPath = join(candidatePath, '.git')
+
+    if (existsSync(gitPath)) {
+      try {
+        const result = installGitHook(candidatePath)
+        if (result.installed && result.message !== 'Git hook already installed') {
+          results.installed++
+        } else {
+          results.skipped++
+        }
+      } catch {
+        results.errors++
+      }
+    }
+  }
+
+  return results
+}

package/src/hooks/index.ts

@@ -17,3 +17,4 @@ export { SmartDeduplicator } from './deduplicator'
 export { HookSessionTracker } from './session-tracker'
 export { appendToQueue, readQueue, clearQueue, drainQueue, getQueuePath } from './queue'
 export { installHooks, uninstallHooks, isHooksInstalled, getHookScriptPath } from './installer'
+export { main as captureMain } from './brain-hook'

package/src/hooks/session-tracker.ts

@@ -6,6 +6,7 @@
 
 import type { Logger } from 'pino'
 import type { EpisodeManager } from '@/memory/episodic/manager'
+import type { MemoryManager } from '@/memory'
 import { ExtractiveSummarizer } from '@/memory/episodic/summarizer'
 import type { CapturedKnowledge } from './types'
 import type { HooksConfig } from '@/config/schema'
@@ -22,6 +23,7 @@ interface SessionState {
 export class HookSessionTracker {
   private logger: Logger
   private episodeManager: EpisodeManager | null
+  private memoryManager: MemoryManager | null
   private summarizer: ExtractiveSummarizer
   private sessions: Map<string, SessionState> = new Map()
   private idleTimers: Map<string, ReturnType<typeof setTimeout>> = new Map()
@@ -31,10 +33,12 @@ export class HookSessionTracker {
   constructor(
     logger: Logger,
     episodeManager: EpisodeManager | null,
-    config?: HooksConfig['sessions']
+    config?: HooksConfig['sessions'],
+    memoryManager?: MemoryManager | null
   ) {
     this.logger = logger.child({ component: 'hook-session-tracker' })
     this.episodeManager = episodeManager
+    this.memoryManager = memoryManager ?? null
     this.summarizer = new ExtractiveSummarizer()
     this.idleTimeoutMs = (config?.idleTimeoutMinutes ?? 30) * 60 * 1000
     this.minEventsForSummary = config?.minEventsForSummary ?? 3
@@ -128,6 +132,50 @@ export class HookSessionTracker {
     await this.endSession(sessionId)
   }
 
+  /**
+   * Build a structured summary from session items.
+   * Format: "Did: ...; Decided: ...; Files: ..."
+   */
+  private buildStructuredSummary(session: SessionState): string {
+    const actions: string[] = []
+    const decisions: string[] = []
+    const files = new Set<string>()
+
+    for (const item of session.items) {
+      // Extract file paths from metadata
+      if (item.metadata?.file_path) {
+        files.add(item.metadata.file_path)
+      }
+      if (item.metadata?.files) {
+        for (const f of Array.isArray(item.metadata.files) ? item.metadata.files : [item.metadata.files]) {
+          files.add(f)
+        }
+      }
+
+      if (item.type === 'decision') {
+        decisions.push(item.content.slice(0, 80))
+      } else if (item.type === 'progress') {
+        actions.push(item.content.slice(0, 80))
+      } else if (item.type === 'pattern' || item.type === 'correction') {
+        actions.push(`[${item.type}] ${item.content.slice(0, 60)}`)
+      }
+    }
+
+    const parts: string[] = []
+    if (actions.length > 0) {
+      parts.push(`Did: ${actions.slice(0, 5).join('; ')}`)
+    }
+    if (decisions.length > 0) {
+      parts.push(`Decided: ${decisions.slice(0, 3).join('; ')}`)
+    }
+    if (files.size > 0) {
+      const fileList = [...files].slice(0, 8)
+      parts.push(`Files: ${fileList.join(', ')}`)
+    }
+
+    return parts.join('. ') || `Session with ${session.items.length} events`
+  }
+
   private async summarizeAndPersist(session: SessionState): Promise<void> {
     if (session.items.length < this.minEventsForSummary) {
       this.logger.debug(
@@ -176,7 +224,10 @@ export class HookSessionTracker {
       message_count: messages.length,
     }
 
-    const summary = this.summarizer.summarize(syntheticEpisode)
+    const extractiveSummary = this.summarizer.summarize(syntheticEpisode)
+
+    // Phase 21: Build structured summary alongside extractive
+    const structuredSummary = this.buildStructuredSummary(session)
 
     // End the episode with summary attached
     if (session.episodeId && this.episodeManager) {
@@ -191,8 +242,33 @@ export class HookSessionTracker {
       }
     }
 
+    // Phase 20+21: Store session summary as a searchable decision
+    // Uses structured summary for better auto-context readability
+    if (this.memoryManager && (extractiveSummary.brief || structuredSummary)) {
+      try {
+        const project = session.project || 'general'
+        const technologies = [...new Set(session.items.flatMap(i => i.technologies))]
+        const summaryContent = `Session summary: ${structuredSummary}${extractiveSummary.key_topics.length > 0 ? ` (Topics: ${extractiveSummary.key_topics.join(', ')})` : ''}`
+
+        await this.memoryManager.rememberDecision(
+          project,
+          'Auto-captured session summary',
+          summaryContent,
+          'Session ended — auto-summarized by passive hooks',
+          { tags: ['session-summary', ...technologies] }
+        )
+
+        this.logger.info(
+          { sessionId: session.sessionId, project },
+          'Session summary stored as searchable memory'
+        )
+      } catch (err) {
+        this.logger.warn({ err, sessionId: session.sessionId }, 'Failed to store session summary')
+      }
+    }
+
     this.logger.info(
-      { sessionId: session.sessionId, summary: summary.brief },
+      { sessionId: session.sessionId, summary: structuredSummary },
       'Session summarized'
     )
   }

package/src/hooks/types.ts

@@ -5,7 +5,7 @@
 /** Claude Code hook stdin JSON format */
 export interface HookInput {
   session_id: string
-  hook_event_name: 'PostToolUse' | 'Stop' | 'PreToolUse'
+  hook_event_name: 'PostToolUse' | 'Stop' | 'PreToolUse' | 'GitCommit'
   cwd: string
   tool_name?: string
   tool_input?: Record<string, any>

package/src/intelligence/index.ts

@@ -0,0 +1,24 @@
+/**
+ * Intelligence Module
+ * Phase 22: Consolidates advanced intelligence features under one namespace.
+ *
+ * Features are lazy-loaded to avoid startup cost when not needed.
+ * Gate on config.intelligence?.enabled for opt-in activation.
+ */
+
+import type { Config } from '@/config'
+
+export async function loadIntelligence(config: Config) {
+  if (!(config as any).intelligence?.enabled) return null
+  return {
+    prediction: await import('./prediction'),
+    reasoning: await import('./reasoning'),
+    temporal: await import('./temporal'),
+    optimization: await import('./optimization'),
+    crossProject: await import('./cross-project')
+  }
+}
+
+// Re-export submodule paths for direct imports
+export * from './optimization/semantic-cache'
+export * from './optimization/precompute'

package/src/knowledge/graph/builder.ts

@@ -27,8 +27,34 @@ export class KnowledgeGraphBuilder {
     await this.entityExtractor.initialize()
   }
 
+  /**
+   * Remove a decision node and its edges from the knowledge graph by decision ID.
+   * Used when a decision is deleted from the store.
+   */
+  removeDecision(decisionId: string): void {
+    try {
+      const nodes = this.graph.findNodes({
+        type: 'decision',
+        properties: { decision_id: decisionId }
+      })
+
+      for (const node of nodes) {
+        this.graph.deleteNode(node.id)
+      }
+
+      if (nodes.length > 0) {
+        this.logger.debug({ decisionId, nodesRemoved: nodes.length }, 'Decision removed from knowledge graph')
+      }
+    } catch (error) {
+      this.logger.error({ error, decisionId }, 'Failed to remove decision from graph')
+    }
+  }
+
   processDecision(input: StoreDecisionInput & { id: string }): void {
     try {
+      // Dedup guard: remove existing node with same decision_id before re-creating
+      this.removeDecision(input.id)
+
       const fullText = `${input.decision} ${input.context} ${input.reasoning}`
       const entities = this.entityExtractor.extract(fullText)
       const relationships = this.relationshipExtractor.extract(fullText, entities)

package/src/memory/chroma/store.ts

@@ -179,7 +179,12 @@ export class ChromaMemoryStore {
           confidence: 1.0,
           created_at: now,
           updated_at: now,
-          decision_id: id
+          decision_id: id,
+          // Phase 19: Include decision fields so memories collection results
+          // can surface decision content without cross-collection lookup
+          decision: input.decision,
+          reasoning: input.reasoning,
+          context: input.context
         }
 
         await memoriesCollection.add({
@@ -493,6 +498,17 @@ export class ChromaMemoryStore {
       const collection = await this.collections.getDecisions()
       await collection.delete({ ids: [id] })
 
+      // Verify deletion succeeded
+      try {
+        const verify = await collection.get({ ids: [id] })
+        if (verify.ids.length > 0) {
+          this.logger.warn({ id }, 'Decision still exists after delete — retrying')
+          await collection.delete({ ids: [id] })
+        }
+      } catch {
+        // Verification query failed, assume delete succeeded
+      }
+
       // ALSO delete from memories collection (dual storage uses same ID)
       try {
         const memoriesCollection = await this.collections.getMemories()
@@ -502,7 +518,7 @@ export class ChromaMemoryStore {
         // Memories collection entry may not exist, that's ok
       }
 
-      this.logger.info({ id }, 'Decision deleted')
+      this.logger.info({ id }, 'Decision deleted from all collections')
 
     } catch (error) {
       this.logger.error({ error, id }, 'Failed to delete decision')

package/src/memory/episodic/manager.ts

@@ -268,6 +268,23 @@ export class EpisodeManager {
     }
   }
 
+  /**
+   * Remove a decision reference from all active episodes.
+   * Called when a decision is deleted to prevent stale references.
+   */
+  unlinkDecision(decisionId: string): void {
+    for (const episode of this.activeEpisodes.values()) {
+      const idx = episode.related_decisions.indexOf(decisionId)
+      if (idx !== -1) {
+        episode.related_decisions.splice(idx, 1)
+        this.logger.debug(
+          { episodeId: episode.id, decisionId },
+          'Decision unlinked from episode'
+        )
+      }
+    }
+  }
+
   private async persistEpisode(episode: Episode): Promise<void> {
     try {
       const collection = await this.collections.getEpisodes()

package/src/memory/index.ts

@@ -56,6 +56,7 @@ export class MemoryManager {
   private initialized: boolean = false
   private useChromaDB: boolean = true
   private onDecisionStoredCallbacks: ((input: any) => void)[] = []
+  private onDecisionDeletedCallbacks: ((id: string) => void)[] = []
 
   constructor(
     dbPath: string,
@@ -195,6 +196,13 @@ export class MemoryManager {
     }
   }
 
+  /**
+   * Add a listener that fires when a decision is deleted
+   */
+  addDecisionDeletedListener(callback: (id: string) => void): void {
+    this.onDecisionDeletedCallbacks.push(callback)
+  }
+
   async rememberDecision(
     project: string,
     context: string,
@@ -244,27 +252,38 @@ export class MemoryManager {
         minSimilarity: options?.minSimilarity || 0.5
       })
       // Transform ChromaDB results to match MemorySearchResult structure
-      return chromaResults.map(r => ({
-        memory: {
-          id: r.id,
-          project: r.metadata.project || options?.project || 'unknown',
-          content: typeof r.content === 'string' ? r.content : JSON.stringify(r.content),
-          createdAt: r.metadata.created_at ? new Date(r.metadata.created_at) : new Date(),
-          metadata: r.metadata
-        },
-        similarity: r.similarity,
-        decision: r.metadata.decision ? {
+      // Includes flat `content` field for direct access (Phase 19)
+      return chromaResults.map(r => {
+        const memoryContent = typeof r.content === 'string' ? r.content : JSON.stringify(r.content)
+        const decisionObj = r.metadata.decision ? {
           id: r.id,
           project: r.metadata.project || options?.project || 'unknown',
           context: r.metadata.context || '',
-          decision: r.metadata.decision || (typeof r.content === 'string' ? r.content : ''),
+          decision: r.metadata.decision || memoryContent,
           reasoning: r.metadata.reasoning || '',
           alternatives: r.metadata.alternatives_considered || '',
           tags: r.metadata.tags || [],
           outcome: r.metadata.outcome,
           createdAt: r.metadata.created_at ? new Date(r.metadata.created_at) : new Date()
         } : undefined
-      }))
+
+        return {
+          // Flat fields for direct access (Phase 19)
+          id: r.id,
+          content: decisionObj ? decisionObj.decision : memoryContent,
+          // Nested fields for backward compatibility
+          memory: {
+            id: r.id,
+            project: r.metadata.project || options?.project || 'unknown',
+            content: memoryContent,
+            createdAt: r.metadata.created_at ? new Date(r.metadata.created_at) : new Date(),
+            metadata: r.metadata
+          },
+          similarity: r.similarity,
+          decision: decisionObj,
+          metadata: r.metadata
+        }
+      })
     } else {
       return await this.search.search(query, {
         project: options?.project,
@@ -520,10 +539,18 @@ export class MemoryManager {
     } else {
       this.store.deleteMemory(id)
     }
+
+    // Notify listeners (e.g., knowledge graph builder) about deletion
+    for (const cb of this.onDecisionDeletedCallbacks) {
+      try {
+        cb(id)
+      } catch {}
+    }
   }
 
   /**
-   * Update a decision by storing a new version and deleting the old one
+   * Update a decision by deleting the old one and storing a new version.
+   * Phase 20: Ensures both ChromaDB and knowledge graph are atomically updated.
    */
   async updateDecision(
     oldId: string,
@@ -533,14 +560,17 @@ export class MemoryManager {
     reasoning: string,
     options?: { alternatives?: string; tags?: string[] }
   ): Promise<string> {
-    // Delete old version
+    // Delete old version — fires onDecisionDeletedCallbacks (graph + episode cleanup)
     try {
       await this.deleteDecision(oldId)
-    } catch {
-      // Old ID might not exist, continue with storing new version
+      this.logger.debug({ oldId }, 'Old decision deleted for update')
+    } catch (error) {
+      this.logger.warn({ error, oldId }, 'Failed to delete old decision during update, storing new version anyway')
     }
-    // Store new version
-    return this.rememberDecision(project, context, decision, reasoning, options)
+    // Store new version — fires onDecisionStoredCallbacks (graph rebuild)
+    const newId = await this.rememberDecision(project, context, decision, reasoning, options)
+    this.logger.debug({ oldId, newId }, 'Decision updated: old deleted, new stored')
+    return newId
   }
 }