claude-brain 0.9.3 → 0.13.0

package/VERSION

@@ -1 +1 @@
-0.9.3
+0.12.0

package/assets/CLAUDE.md

@@ -1,3 +1,11 @@
 # Claude Brain
 
-Claude Brain gives you persistent memory across sessions. Just use the `brain` tool naturally — tell it what you're doing, what you decided, or what you need to recall. It handles everything automatically.
+Brain works automatically in the background — you don't need to call it.
+
+Use the `brain` tool ONLY when you want to:
+- Explicitly store a decision: "I decided to use Redis for caching"
+- Ask a specific question: "What did we decide about auth?"
+- Update something: "Changed my mind, use Postgres instead"
+- Delete something: "Remove the note about migrations"
+
+Everything else (session tracking, file captures, git commits, context loading) happens automatically.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-brain",
-  "version": "0.9.3",
+  "version": "0.13.0",
   "description": "Local development assistant bridging Obsidian vaults with Claude Code via MCP",
   "type": "module",
   "main": "src/index.ts",

package/src/automation/phase12-manager.ts

@@ -0,0 +1,456 @@
+/**
+ * Phase 12 Manager
+ * Advanced Memory & Intelligent Automation
+ *
+ * Orchestrates all Phase 12 features:
+ * - Pattern Recognition
+ * - Learning System
+ * - Knowledge Extraction
+ * - Auto-Context Loading
+ * - Decision Detection
+ * - Proactive Recall
+ */
+
+import type { Logger } from 'pino'
+import type { VaultManager } from '@/vault'
+import type { MemoryManager } from '@/memory'
+import type { ContextManager } from '@/context'
+import { PatternRecognizer, type Pattern } from '@/memory/patterns'
+import { LearningSystem, type LearningInsights } from '@/memory/learning'
+import { KnowledgeExtractor, type ExtractedKnowledge } from '@/memory/knowledge-extractor'
+import {
+  ProjectDetector,
+  AutoContextLoader,
+  DecisionDetector,
+  ProactiveRecallEngine,
+  type DetectedProject,
+  type DetectedDecision,
+  type RecallResult
+} from '@/automation'
+
+export interface Phase12Config {
+  /**
+   * Enable automatic context loading on startup
+   * @default true
+   */
+  autoLoadContext: boolean
+
+  /**
+   * Enable automatic decision detection and saving
+   * @default true
+   */
+  autoDetectDecisions: boolean
+
+  /**
+   * Enable proactive memory recall
+   * @default true
+   */
+  enableProactiveRecall: boolean
+
+  /**
+   * Minimum confidence for auto-saving decisions
+   * @default 0.7
+   */
+  decisionConfidenceThreshold: number
+
+  /**
+   * Enable pattern analysis on startup
+   * @default false
+   */
+  analyzePatternsonStartup: boolean
+
+  /**
+   * Enable knowledge extraction from messages
+   * @default true
+   */
+  enableKnowledgeExtraction: boolean
+}
+
+const DEFAULT_CONFIG: Phase12Config = {
+  autoLoadContext: true,
+  autoDetectDecisions: true,
+  enableProactiveRecall: true,
+  decisionConfidenceThreshold: 0.7,
+  analyzePatternsonStartup: false,
+  enableKnowledgeExtraction: true
+}
+
+export interface MessageProcessingResult {
+  recalledMemories?: RecallResult
+  detectedDecision?: DetectedDecision
+  extractedKnowledge?: ExtractedKnowledge[]
+  detectedProject?: DetectedProject
+  decisionSaved?: boolean
+  decisionId?: string
+}
+
+export interface Phase12Stats {
+  patterns: {
+    total: number
+    byType: Record<string, number>
+  }
+  learning: LearningInsights
+  automation: {
+    contextLoaded: boolean
+    currentProject: string | null
+    recallStats: {
+      totalRecalls: number
+      successfulRecalls: number
+      averageRelevance: number
+    }
+  }
+}
+
+export class Phase12Manager {
+  private logger: Logger
+  private config: Phase12Config
+  private initialized = false
+
+  // Advanced Memory
+  public readonly patterns: PatternRecognizer
+  public readonly learning: LearningSystem
+  public readonly knowledge: KnowledgeExtractor
+
+  // Intelligent Automation
+  public readonly projectDetector: ProjectDetector
+  public readonly autoContext: AutoContextLoader
+  public readonly decisionDetector: DecisionDetector
+  public readonly proactiveRecall: ProactiveRecallEngine
+
+  constructor(
+    logger: Logger,
+    vault: VaultManager,
+    memory: MemoryManager,
+    context: ContextManager,
+    config: Partial<Phase12Config> = {}
+  ) {
+    this.logger = logger.child({ component: 'phase12-manager' })
+    this.config = { ...DEFAULT_CONFIG, ...config }
+
+    // Initialize advanced memory features
+    this.patterns = new PatternRecognizer(logger, memory)
+    this.learning = new LearningSystem(logger, memory)
+    this.knowledge = new KnowledgeExtractor(logger, memory)
+
+    // Initialize intelligent automation
+    this.projectDetector = new ProjectDetector(logger, vault)
+    this.autoContext = new AutoContextLoader(
+      logger,
+      context,
+      this.projectDetector
+    )
+    this.decisionDetector = new DecisionDetector(logger, memory)
+    this.proactiveRecall = new ProactiveRecallEngine(logger, memory)
+
+    this.logger.info(
+      { config: this.config },
+      'Phase 12 Manager created'
+    )
+  }
+
+  /**
+   * Initialize all Phase 12 features
+   */
+  async initialize(): Promise<void> {
+    if (this.initialized) {
+      this.logger.warn('Phase 12 already initialized')
+      return
+    }
+
+    this.logger.info('Initializing Phase 12 features...')
+
+    try {
+      // Start auto-context loader
+      if (this.config.autoLoadContext) {
+        await this.autoContext.initialize()
+        this.logger.info('Auto-context loader initialized')
+      }
+
+      // Run initial pattern analysis if enabled
+      if (this.config.analyzePatternsonStartup) {
+        const patterns = await this.patterns.analyzePatterns()
+        this.logger.info(
+          { patternCount: patterns.length },
+          'Initial pattern analysis complete'
+        )
+      }
+
+      this.initialized = true
+      this.logger.info('Phase 12 initialization complete')
+    } catch (error) {
+      this.logger.error({ error }, 'Phase 12 initialization failed')
+      throw error
+    }
+  }
+
+  /**
+   * Check if Phase 12 is initialized
+   */
+  isInitialized(): boolean {
+    return this.initialized
+  }
+
+  /**
+   * Process incoming message with all Phase 12 features
+   */
+  async processMessage(
+    message: string,
+    project?: string
+  ): Promise<MessageProcessingResult> {
+    const results: MessageProcessingResult = {}
+
+    // Use detected project if not provided
+    const targetProject = project || this.autoContext.getCurrentProject() || undefined
+
+    // 1. Proactive recall
+    if (this.config.enableProactiveRecall) {
+      if (this.proactiveRecall.shouldRecall(message)) {
+        results.recalledMemories = await this.proactiveRecall.recall(
+          message,
+          targetProject
+        ) || undefined
+      }
+    }
+
+    // 2. Decision detection
+    if (this.config.autoDetectDecisions && targetProject) {
+      const decision = this.decisionDetector.detectDecision(message, targetProject)
+
+      if (decision && decision.confidence >= this.config.decisionConfidenceThreshold) {
+        results.detectedDecision = decision
+
+        // Auto-save if confidence is high enough
+        const decisionId = await this.decisionDetector.autoSaveDecision(
+          decision,
+          targetProject
+        )
+
+        if (decisionId) {
+          results.decisionSaved = true
+          results.decisionId = decisionId
+        }
+      }
+    }
+
+    // 3. Knowledge extraction
+    if (this.config.enableKnowledgeExtraction) {
+      const extracted = await this.knowledge.extractFromConversation(
+        message,
+        targetProject
+      )
+
+      if (extracted.knowledge.length > 0) {
+        results.extractedKnowledge = extracted.knowledge
+      }
+    }
+
+    // Log processing results
+    if (Object.keys(results).length > 0) {
+      this.logger.debug(
+        {
+          hasRecall: !!results.recalledMemories,
+          hasDecision: !!results.detectedDecision,
+          knowledgeCount: results.extractedKnowledge?.length || 0,
+          decisionSaved: results.decisionSaved
+        },
+        'Message processed with Phase 12 features'
+      )
+    }
+
+    return results
+  }
+
+  /**
+   * Process outgoing response for decisions
+   * Call this with Claude's responses to detect and save decisions
+   */
+  async processResponse(
+    response: string,
+    project?: string
+  ): Promise<MessageProcessingResult> {
+    const results: MessageProcessingResult = {}
+    const targetProject = project || this.autoContext.getCurrentProject() || undefined
+
+    // Decision detection on responses (Claude's decisions)
+    if (this.config.autoDetectDecisions && targetProject) {
+      const decision = this.decisionDetector.detectDecision(response, targetProject)
+
+      if (decision && decision.confidence >= this.config.decisionConfidenceThreshold) {
+        results.detectedDecision = decision
+
+        const decisionId = await this.decisionDetector.autoSaveDecision(
+          decision,
+          targetProject
+        )
+
+        if (decisionId) {
+          results.decisionSaved = true
+          results.decisionId = decisionId
+          this.logger.info(
+            { decisionId, project: targetProject },
+            'Decision auto-saved from response'
+          )
+        }
+      }
+    }
+
+    // Knowledge extraction from responses
+    if (this.config.enableKnowledgeExtraction) {
+      const extracted = await this.knowledge.extractFromConversation(
+        response,
+        targetProject
+      )
+
+      if (extracted.knowledge.length > 0) {
+        results.extractedKnowledge = extracted.knowledge
+      }
+    }
+
+    return results
+  }
+
+  /**
+   * Get proactively recalled context for a query
+   */
+  async getRecalledContext(query: string, project?: string): Promise<string | null> {
+    const result = await this.proactiveRecall.recall(
+      query,
+      project || this.autoContext.getCurrentProject() || undefined
+    )
+
+    return result?.formattedContext || null
+  }
+
+  /**
+   * Get relevant patterns for a query
+   */
+  async getRelevantPatterns(query: string): Promise<Pattern[]> {
+    return this.patterns.getRelevantPatterns(query)
+  }
+
+  /**
+   * Record a correction for learning
+   */
+  async recordCorrection(
+    original: string,
+    corrected: string,
+    reasoning: string,
+    project?: string
+  ): Promise<string> {
+    const targetProject = project || this.autoContext.getCurrentProject() || 'global'
+    return this.learning.recordCorrection(original, corrected, reasoning, targetProject)
+  }
+
+  /**
+   * Get comprehensive Phase 12 statistics
+   */
+  getStats(): Phase12Stats {
+    const allPatterns = this.patterns.getAllPatterns()
+    const patternsByType: Record<string, number> = {}
+
+    for (const pattern of allPatterns) {
+      patternsByType[pattern.type] = (patternsByType[pattern.type] || 0) + 1
+    }
+
+    const recallStats = this.proactiveRecall.getStats()
+
+    return {
+      patterns: {
+        total: allPatterns.length,
+        byType: patternsByType
+      },
+      learning: this.learning.getLearningInsights(),
+      automation: {
+        contextLoaded: this.autoContext.getCurrentContext() !== undefined,
+        currentProject: this.autoContext.getCurrentProject(),
+        recallStats: {
+          totalRecalls: recallStats.totalRecalls,
+          successfulRecalls: recallStats.successfulRecalls,
+          averageRelevance: recallStats.averageRelevance
+        }
+      }
+    }
+  }
+
+  /**
+   * Get formatted status report
+   */
+  getStatusReport(): string {
+    const stats = this.getStats()
+    const parts: string[] = []
+
+    parts.push('# Phase 12 Status Report\n')
+
+    // Current project
+    parts.push('## Current Context')
+    if (stats.automation.currentProject) {
+      parts.push(`- **Project:** ${stats.automation.currentProject}`)
+      parts.push(`- **Context Loaded:** Yes`)
+    } else {
+      parts.push('- **Project:** Not detected (use smart_context to load project context)')
+      parts.push('- **Context Loaded:** No')
+    }
+    parts.push('')
+
+    // Pattern analysis
+    parts.push('## Pattern Analysis')
+    parts.push(`- **Total Patterns:** ${stats.patterns.total}`)
+    if (stats.patterns.total === 0) {
+      parts.push('  *No patterns stored yet. Use `recognize_pattern` to document reusable solutions.*')
+    } else {
+      for (const [type, count] of Object.entries(stats.patterns.byType)) {
+        parts.push(`  - ${type}: ${count}`)
+      }
+    }
+    parts.push('')
+
+    // Learning system
+    parts.push('## Learning System')
+    parts.push(`- **Total Corrections:** ${stats.learning.correctionCount}`)
+    if (stats.learning.correctionCount === 0) {
+      parts.push('  *No corrections recorded yet. Use `record_correction` to document lessons learned.*')
+    }
+    parts.push(`- **Categories Improved:** ${stats.learning.categoriesImproved.join(', ') || 'None'}`)
+    if (stats.learning.preferences.length > 0) {
+      parts.push('- **Top Preferences:**')
+      for (const pref of stats.learning.preferences.slice(0, 3)) {
+        parts.push(`  - ${pref.category}: ${Math.round(pref.strength * 100)}% confidence`)
+      }
+    }
+    parts.push('')
+
+    // Proactive recall
+    parts.push('## Proactive Recall')
+    parts.push(`- **Total Recalls:** ${stats.automation.recallStats.totalRecalls}`)
+    parts.push(`- **Successful:** ${stats.automation.recallStats.successfulRecalls}`)
+    const successRate = stats.automation.recallStats.totalRecalls > 0
+      ? Math.round((stats.automation.recallStats.successfulRecalls / stats.automation.recallStats.totalRecalls) * 100)
+      : 0
+    parts.push(`- **Success Rate:** ${successRate}%`)
+    parts.push(`- **Average Relevance:** ${Math.round(stats.automation.recallStats.averageRelevance * 100)}%`)
+
+    if (stats.automation.recallStats.totalRecalls === 0) {
+      parts.push('\n*Proactive recall activates automatically when you ask questions or request recommendations.*')
+    }
+
+    return parts.join('\n')
+  }
+
+  /**
+   * Cleanup and reset Phase 12
+   */
+  cleanup(): void {
+    this.autoContext.clearAllContexts()
+    this.patterns.clearPatterns()
+    this.learning.clearLearning()
+    this.proactiveRecall.resetStats()
+    this.initialized = false
+    this.logger.info('Phase 12 cleaned up')
+  }
+}
+
+// Re-export types
+export type { Pattern } from '@/memory/patterns'
+export type { Correction, Preference, LearningInsights } from '@/memory/learning'
+export type { ExtractedKnowledge, ExtractionResult } from '@/memory/knowledge-extractor'
+export type { DetectedProject, DetectedDecision, RecallResult } from '@/automation'

package/src/automation/project-detector.ts

@@ -263,6 +263,19 @@ export class ProjectDetector {
     return matrix[b.length][a.length]
   }
 
+  /**
+   * Check if a project has any existing memories.
+   * Returns true if no memories found (i.e., it's a new project).
+   */
+  async isNewProject(projectName: string): Promise<boolean> {
+    try {
+      const projects = await this.vault.listProjects()
+      return !projects.includes(projectName)
+    } catch {
+      return true
+    }
+  }
+
   /**
    * Get project suggestions based on working directory
    */

package/src/automation/repo-scanner.ts

@@ -0,0 +1,205 @@
+/**
+ * Repo Scanner
+ * Phase 22: Scans a repository to extract initial project context.
+ * Used on first encounter or via `claude-brain init`.
+ */
+
+import fs from 'fs/promises'
+import path from 'path'
+import { execSync } from 'child_process'
+
+export interface ProjectContext {
+  name: string
+  description: string
+  techStack: string[]
+  structure: string
+  recentActivity: string
+  projectInstructions?: string
+}
+
+/**
+ * Scan a repository and extract project context.
+ */
+export async function scanRepo(repoPath: string): Promise<ProjectContext> {
+  const name = path.basename(repoPath)
+
+  // Detect tech stack and name from manifest files
+  const manifest = await detectManifest(repoPath)
+  const projectName = manifest?.name || name
+  const techStack = manifest?.techStack || []
+
+  // Read README for description
+  const description = await readDescription(repoPath)
+
+  // Get directory structure
+  const structure = await getDirectoryTree(repoPath, 2)
+
+  // Get recent git activity
+  const recentActivity = getRecentGitActivity(repoPath)
+
+  // Read CLAUDE.md if present
+  const projectInstructions = await readClaudeMd(repoPath)
+
+  return {
+    name: projectName,
+    description,
+    techStack,
+    structure,
+    recentActivity,
+    projectInstructions
+  }
+}
+
+interface ManifestInfo {
+  name: string
+  techStack: string[]
+}
+
+async function detectManifest(repoPath: string): Promise<ManifestInfo | null> {
+  // Try package.json (Node.js)
+  try {
+    const content = await fs.readFile(path.join(repoPath, 'package.json'), 'utf-8')
+    const pkg = JSON.parse(content)
+    return {
+      name: (pkg.name || '').replace(/^@[^/]+\//, ''),
+      techStack: extractTechStack(pkg)
+    }
+  } catch { /* not a Node project */ }
+
+  // Try pyproject.toml (Python)
+  try {
+    const content = await fs.readFile(path.join(repoPath, 'pyproject.toml'), 'utf-8')
+    const nameMatch = content.match(/name\s*=\s*"([^"]+)"/)
+    const deps = content.match(/dependencies\s*=\s*\[([\s\S]*?)\]/)?.[1] || ''
+    const techStack = ['python']
+    if (deps.includes('django')) techStack.push('django')
+    if (deps.includes('fastapi')) techStack.push('fastapi')
+    if (deps.includes('flask')) techStack.push('flask')
+    if (deps.includes('pytest')) techStack.push('pytest')
+    return { name: nameMatch?.[1] || '', techStack }
+  } catch { /* not a Python project */ }
+
+  // Try Cargo.toml (Rust)
+  try {
+    const content = await fs.readFile(path.join(repoPath, 'Cargo.toml'), 'utf-8')
+    const nameMatch = content.match(/name\s*=\s*"([^"]+)"/)
+    return { name: nameMatch?.[1] || '', techStack: ['rust'] }
+  } catch { /* not a Rust project */ }
+
+  // Try go.mod (Go)
+  try {
+    const content = await fs.readFile(path.join(repoPath, 'go.mod'), 'utf-8')
+    const moduleMatch = content.match(/module\s+(\S+)/)
+    const moduleName = moduleMatch?.[1]?.split('/').pop() || ''
+    return { name: moduleName, techStack: ['go'] }
+  } catch { /* not a Go project */ }
+
+  return null
+}
+
+function extractTechStack(pkg: any): string[] {
+  const stack: string[] = []
+  const allDeps = { ...pkg.dependencies, ...pkg.devDependencies }
+
+  // Runtime
+  if (allDeps.typescript || allDeps['@types/node']) stack.push('typescript')
+  else stack.push('javascript')
+
+  // Frameworks
+  if (allDeps.react || allDeps['react-dom']) stack.push('react')
+  if (allDeps.next) stack.push('nextjs')
+  if (allDeps.vue) stack.push('vue')
+  if (allDeps.svelte) stack.push('svelte')
+  if (allDeps.express) stack.push('express')
+  if (allDeps.hono) stack.push('hono')
+  if (allDeps.fastify) stack.push('fastify')
+
+  // Tools
+  if (allDeps.bun || pkg.devDependencies?.['@types/bun']) stack.push('bun')
+  if (allDeps.vitest) stack.push('vitest')
+  if (allDeps.jest) stack.push('jest')
+  if (allDeps.tailwindcss) stack.push('tailwind')
+  if (allDeps.prisma || allDeps['@prisma/client']) stack.push('prisma')
+  if (allDeps.drizzle || allDeps['drizzle-orm']) stack.push('drizzle')
+
+  // AI/ML
+  if (allDeps['@modelcontextprotocol/sdk']) stack.push('mcp')
+  if (allDeps['@anthropic-ai/sdk']) stack.push('claude-api')
+  if (allDeps.openai) stack.push('openai')
+  if (allDeps.langchain) stack.push('langchain')
+
+  return stack
+}
+
+async function readDescription(repoPath: string): Promise<string> {
+  for (const readme of ['README.md', 'readme.md', 'Readme.md']) {
+    try {
+      const content = await fs.readFile(path.join(repoPath, readme), 'utf-8')
+      return content.slice(0, 500).trim()
+    } catch { /* no readme */ }
+  }
+  return ''
+}
+
+async function getDirectoryTree(repoPath: string, maxDepth: number): Promise<string> {
+  const IGNORED = new Set([
+    'node_modules', '.git', 'dist', 'build', '.next', '__pycache__',
+    '.venv', 'venv', '.mypy_cache', '.pytest_cache', 'target',
+    '.turbo', '.vercel', 'coverage', '.nyc_output'
+  ])
+
+  const lines: string[] = []
+
+  async function walk(dir: string, depth: number, prefix: string) {
+    if (depth > maxDepth) return
+
+    let entries: Awaited<ReturnType<typeof fs.readdir>>
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true })
+    } catch {
+      return
+    }
+
+    const filtered = entries
+      .filter(e => !e.name.startsWith('.') || e.name === '.github')
+      .filter(e => !IGNORED.has(e.name))
+      .sort((a, b) => {
+        // Directories first
+        if (a.isDirectory() && !b.isDirectory()) return -1
+        if (!a.isDirectory() && b.isDirectory()) return 1
+        return a.name.localeCompare(b.name)
+      })
+
+    for (const entry of filtered.slice(0, 30)) { // Cap at 30 per level
+      const isDir = entry.isDirectory()
+      lines.push(`${prefix}${isDir ? entry.name + '/' : entry.name}`)
+      if (isDir) {
+        await walk(path.join(dir, entry.name), depth + 1, prefix + '  ')
+      }
+    }
+  }
+
+  await walk(repoPath, 0, '')
+  return lines.join('\n')
+}
+
+function getRecentGitActivity(repoPath: string): string {
+  try {
+    return execSync('git log --oneline -10', {
+      cwd: repoPath,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    }).trim()
+  } catch {
+    return ''
+  }
+}
+
+async function readClaudeMd(repoPath: string): Promise<string | undefined> {
+  try {
+    const content = await fs.readFile(path.join(repoPath, 'CLAUDE.md'), 'utf-8')
+    return content.trim()
+  } catch {
+    return undefined
+  }
+}