claude-brain 0.3.0

package/src/cross-project/generalizer.ts

@@ -0,0 +1,283 @@
+/**
+ * Pattern Generalizer
+ * Finds common patterns across multiple projects
+ */
+
+import type { Logger } from 'pino'
+import type { CollectionManager } from '@/memory/chroma/collection-manager'
+import type { EmbeddingProvider } from '@/memory/chroma/embeddings'
+
+export interface GeneralizedPattern {
+  description: string
+  projects: string[]
+  occurrences: number
+  confidence: number
+  examples: Array<{
+    project: string
+    content: string
+    id: string
+  }>
+}
+
+export interface GeneralizationResult {
+  patterns: GeneralizedPattern[]
+  projectsAnalyzed: string[]
+  totalDecisionsAnalyzed: number
+}
+
+export class PatternGeneralizer {
+  private logger: Logger
+  private collections: CollectionManager
+  private embeddings?: EmbeddingProvider
+
+  constructor(logger: Logger, collections: CollectionManager, embeddings?: EmbeddingProvider) {
+    this.logger = logger.child({ component: 'pattern-generalizer' })
+    this.collections = collections
+    this.embeddings = embeddings
+  }
+
+  /**
+   * Find patterns that appear across multiple projects
+   */
+  async findCrossProjectPatterns(options: {
+    minProjects?: number
+    limit?: number
+    query?: string
+  } = {}): Promise<GeneralizationResult> {
+    const { minProjects = 2, limit = 20, query } = options
+
+    // Fetch all decisions
+    const allDecisions = await this.fetchAllDecisions(query)
+
+    // Group by project
+    const byProject = new Map<string, Array<{ id: string; content: string }>>()
+    for (const d of allDecisions) {
+      const project = d.project
+      if (!byProject.has(project)) byProject.set(project, [])
+      byProject.get(project)!.push({ id: d.id, content: d.content })
+    }
+
+    const projects = Array.from(byProject.keys())
+
+    if (projects.length < minProjects) {
+      return {
+        patterns: [],
+        projectsAnalyzed: projects,
+        totalDecisionsAnalyzed: allDecisions.length
+      }
+    }
+
+    // Find cross-project patterns using term overlap
+    const crossPatterns = this.findCommonTermPatterns(byProject, minProjects)
+
+    // If embeddings are available, also do semantic clustering
+    if (this.embeddings && allDecisions.length > 0) {
+      const semanticPatterns = await this.findSemanticClusters(allDecisions, minProjects)
+      crossPatterns.push(...semanticPatterns)
+    }
+
+    // Deduplicate and rank
+    const deduped = this.deduplicatePatterns(crossPatterns)
+    const ranked = deduped
+      .sort((a, b) => b.occurrences * b.confidence - a.occurrences * a.confidence)
+      .slice(0, limit)
+
+    return {
+      patterns: ranked,
+      projectsAnalyzed: projects,
+      totalDecisionsAnalyzed: allDecisions.length
+    }
+  }
+
+  private async fetchAllDecisions(query?: string): Promise<Array<{
+    id: string
+    content: string
+    project: string
+  }>> {
+    try {
+      const collection = await this.collections.getDecisions()
+
+      if (query && this.embeddings) {
+        const embedding = await this.embeddings.generate(query)
+        const results = await collection.query({
+          queryEmbeddings: [embedding],
+          nResults: 100,
+          include: ['documents', 'metadatas', 'distances']
+        })
+
+        if (!results.ids || !results.ids[0]) return []
+
+        return results.ids[0].map((id: string, i: number) => ({
+          id,
+          content: results.documents?.[0]?.[i] || '',
+          project: (results.metadatas?.[0]?.[i] as any)?.project || ''
+        }))
+      }
+
+      const results = await collection.get({
+        include: ['documents', 'metadatas']
+      })
+
+      return results.ids.map((id, i) => ({
+        id,
+        content: results.documents![i] as string || '',
+        project: (results.metadatas![i] as any)?.project || ''
+      }))
+    } catch (error) {
+      this.logger.warn({ error }, 'Failed to fetch decisions for generalization')
+      return []
+    }
+  }
+
+  private findCommonTermPatterns(
+    byProject: Map<string, Array<{ id: string; content: string }>>,
+    minProjects: number
+  ): GeneralizedPattern[] {
+    // Extract key terms per project
+    const projectTerms = new Map<string, Map<string, Array<{ id: string; content: string }>>>()
+
+    for (const [project, decisions] of byProject) {
+      const terms = new Map<string, Array<{ id: string; content: string }>>()
+
+      for (const d of decisions) {
+        const words = this.extractKeyTerms(d.content)
+
+        for (const word of words) {
+          if (!terms.has(word)) terms.set(word, [])
+          terms.get(word)!.push(d)
+        }
+      }
+
+      projectTerms.set(project, terms)
+    }
+
+    // Find terms that appear across multiple projects
+    const allTerms = new Map<string, { projects: Set<string>; examples: Array<{ project: string; content: string; id: string }> }>()
+
+    for (const [project, terms] of projectTerms) {
+      for (const [term, decisions] of terms) {
+        if (!allTerms.has(term)) {
+          allTerms.set(term, { projects: new Set(), examples: [] })
+        }
+        const entry = allTerms.get(term)!
+        entry.projects.add(project)
+        for (const d of decisions.slice(0, 2)) {
+          entry.examples.push({ project, content: d.content.slice(0, 150), id: d.id })
+        }
+      }
+    }
+
+    // Filter to terms appearing in multiple projects
+    const patterns: GeneralizedPattern[] = []
+
+    for (const [term, data] of allTerms) {
+      if (data.projects.size >= minProjects) {
+        patterns.push({
+          description: `Common pattern around: "${term}"`,
+          projects: Array.from(data.projects),
+          occurrences: data.examples.length,
+          confidence: Math.min(data.projects.size / byProject.size, 1),
+          examples: data.examples.slice(0, 5)
+        })
+      }
+    }
+
+    return patterns
+  }
+
+  private async findSemanticClusters(
+    decisions: Array<{ id: string; content: string; project: string }>,
+    minProjects: number
+  ): Promise<GeneralizedPattern[]> {
+    if (!this.embeddings) return []
+
+    const patterns: GeneralizedPattern[] = []
+
+    try {
+      // Simple approach: for each decision, find similar ones across projects
+      const sample = decisions.slice(0, 20) // Limit to avoid too many embedding calls
+
+      for (const decision of sample) {
+        const collection = await this.collections.getDecisions()
+        const embedding = await this.embeddings.generate(decision.content)
+
+        const results = await collection.query({
+          queryEmbeddings: [embedding],
+          nResults: 10,
+          include: ['documents', 'metadatas', 'distances']
+        })
+
+        if (!results.ids || !results.ids[0]) continue
+
+        const crossProjectMatches: Array<{ project: string; content: string; id: string }> = []
+        const matchProjects = new Set<string>()
+
+        for (let i = 0; i < results.ids[0].length; i++) {
+          const similarity = 1 - (results.distances?.[0]?.[i] || 0)
+          if (similarity < 0.6) continue
+
+          const matchProject = (results.metadatas?.[0]?.[i] as any)?.project || ''
+          if (matchProject && matchProject !== decision.project) {
+            matchProjects.add(matchProject)
+            crossProjectMatches.push({
+              project: matchProject,
+              content: (results.documents?.[0]?.[i] || '').slice(0, 150),
+              id: results.ids[0][i]
+            })
+          }
+        }
+
+        matchProjects.add(decision.project)
+
+        if (matchProjects.size >= minProjects) {
+          patterns.push({
+            description: `Similar approaches: "${decision.content.slice(0, 100)}..."`,
+            projects: Array.from(matchProjects),
+            occurrences: crossProjectMatches.length + 1,
+            confidence: 0.7,
+            examples: [
+              { project: decision.project, content: decision.content.slice(0, 150), id: decision.id },
+              ...crossProjectMatches.slice(0, 4)
+            ]
+          })
+        }
+      }
+    } catch (error) {
+      this.logger.debug({ error }, 'Failed to find semantic clusters')
+    }
+
+    return patterns
+  }
+
+  private deduplicatePatterns(patterns: GeneralizedPattern[]): GeneralizedPattern[] {
+    const seen = new Set<string>()
+    const deduped: GeneralizedPattern[] = []
+
+    for (const pattern of patterns) {
+      const key = pattern.description.toLowerCase().slice(0, 50)
+      if (!seen.has(key)) {
+        seen.add(key)
+        deduped.push(pattern)
+      }
+    }
+
+    return deduped
+  }
+
+  private extractKeyTerms(text: string): string[] {
+    const stopWords = new Set([
+      'the', 'and', 'for', 'are', 'but', 'not', 'all', 'can', 'was',
+      'has', 'had', 'been', 'have', 'with', 'this', 'that', 'from',
+      'they', 'will', 'would', 'there', 'their', 'what', 'about',
+      'which', 'when', 'make', 'like', 'just', 'also', 'should',
+      'use', 'using', 'used', 'because', 'instead', 'project',
+      'decision', 'decided', 'recommend', 'context', 'reasoning'
+    ])
+
+    return text
+      .toLowerCase()
+      .replace(/[^a-z0-9\s-]/g, ' ')
+      .split(/\s+/)
+      .filter(w => w.length > 3 && !stopWords.has(w))
+  }
+}

package/src/cross-project/index.ts

@@ -0,0 +1,13 @@
+/**
+ * Cross-Project Intelligence Module
+ * Phase 15.4 - Pattern generalization, project affinity, knowledge transfer
+ */
+
+export { PatternGeneralizer } from './generalizer'
+export type { GeneralizedPattern, GeneralizationResult } from './generalizer'
+
+export { AffinityCalculator } from './affinity'
+export type { ProjectAffinity } from './affinity'
+
+export { KnowledgeTransfer } from './transfer'
+export type { TransferableKnowledge, TransferItem } from './transfer'

package/src/cross-project/transfer.ts

@@ -0,0 +1,201 @@
+/**
+ * Knowledge Transfer
+ * Transfer knowledge from one project to another based on similarity
+ */
+
+import type { Logger } from 'pino'
+import type { CollectionManager } from '@/memory/chroma/collection-manager'
+import type { EmbeddingProvider } from '@/memory/chroma/embeddings'
+
+export interface TransferableKnowledge {
+  sourceProject: string
+  targetProject: string
+  items: TransferItem[]
+  affinityScore: number
+}
+
+export interface TransferItem {
+  type: 'decision' | 'pattern' | 'correction'
+  id: string
+  content: string
+  relevance: number
+  reasoning: string
+}
+
+export class KnowledgeTransfer {
+  private logger: Logger
+  private collections: CollectionManager
+  private embeddings?: EmbeddingProvider
+
+  constructor(logger: Logger, collections: CollectionManager, embeddings?: EmbeddingProvider) {
+    this.logger = logger.child({ component: 'knowledge-transfer' })
+    this.collections = collections
+    this.embeddings = embeddings
+  }
+
+  /**
+   * Find transferable knowledge from source project to apply to target project
+   */
+  async findTransferable(sourceProject: string, targetProject: string, options: {
+    limit?: number
+    minRelevance?: number
+  } = {}): Promise<TransferableKnowledge> {
+    const { limit = 10, minRelevance = 0.4 } = options
+
+    // Get target project's decisions to understand its context
+    const targetContext = await this.getProjectContext(targetProject)
+
+    if (!targetContext) {
+      return {
+        sourceProject,
+        targetProject,
+        items: [],
+        affinityScore: 0
+      }
+    }
+
+    // Search source project for relevant knowledge
+    const items: TransferItem[] = []
+
+    // Decisions
+    const decisions = await this.searchSourceProject(
+      sourceProject,
+      targetContext,
+      'decisions',
+      limit,
+      minRelevance
+    )
+    items.push(...decisions)
+
+    // Patterns
+    const patterns = await this.searchSourceProject(
+      sourceProject,
+      targetContext,
+      'patterns',
+      limit,
+      minRelevance
+    )
+    items.push(...patterns)
+
+    // Corrections
+    const corrections = await this.searchSourceProject(
+      sourceProject,
+      targetContext,
+      'corrections',
+      limit,
+      minRelevance
+    )
+    items.push(...corrections)
+
+    // Sort by relevance
+    items.sort((a, b) => b.relevance - a.relevance)
+
+    // Calculate affinity
+    const affinityScore = items.length > 0
+      ? items.reduce((sum, i) => sum + i.relevance, 0) / items.length
+      : 0
+
+    return {
+      sourceProject,
+      targetProject,
+      items: items.slice(0, limit),
+      affinityScore
+    }
+  }
+
+  private async getProjectContext(project: string): Promise<string | null> {
+    try {
+      const collection = await this.collections.getDecisions()
+
+      const results = await collection.get({
+        where: { project: { $eq: project } },
+        include: ['documents'],
+        limit: 20
+      })
+
+      if (results.ids.length === 0) return null
+
+      // Combine recent decisions into a context string
+      return results.documents!
+        .slice(0, 10)
+        .map(d => d as string)
+        .join(' ')
+    } catch (error) {
+      this.logger.debug({ error, project }, 'Failed to get project context')
+      return null
+    }
+  }
+
+  private async searchSourceProject(
+    sourceProject: string,
+    targetContext: string,
+    collectionType: 'decisions' | 'patterns' | 'corrections',
+    limit: number,
+    minRelevance: number
+  ): Promise<TransferItem[]> {
+    try {
+      let collection
+      let type: 'decision' | 'pattern' | 'correction'
+
+      switch (collectionType) {
+        case 'decisions':
+          collection = await this.collections.getDecisions()
+          type = 'decision'
+          break
+        case 'patterns':
+          collection = await this.collections.getPatterns()
+          type = 'pattern'
+          break
+        case 'corrections':
+          collection = await this.collections.getCorrections()
+          type = 'correction'
+          break
+      }
+
+      const where: any = { project: { $eq: sourceProject } }
+
+      let results: any
+
+      if (this.embeddings) {
+        // Use truncated target context for embedding
+        const queryText = targetContext.slice(0, 500)
+        const embedding = await this.embeddings.generate(queryText)
+        results = await collection.query({
+          queryEmbeddings: [embedding],
+          nResults: limit,
+          where,
+          include: ['documents', 'metadatas', 'distances']
+        })
+      } else {
+        results = await collection.query({
+          queryTexts: [targetContext.slice(0, 500)],
+          nResults: limit,
+          where,
+          include: ['documents', 'metadatas', 'distances']
+        })
+      }
+
+      if (!results.ids || !results.ids[0]) return []
+
+      const items: TransferItem[] = []
+
+      for (let i = 0; i < results.ids[0].length; i++) {
+        const similarity = 1 - (results.distances?.[0]?.[i] || 0)
+        if (similarity < minRelevance) continue
+
+        items.push({
+          type,
+          id: results.ids[0][i],
+          content: results.documents?.[0]?.[i] || '',
+          relevance: similarity,
+          reasoning: `Relevant ${type} from ${sourceProject} (${Math.round(similarity * 100)}% match)`
+        })
+      }
+
+      return items
+    } catch (error) {
+      this.logger.debug({ error, sourceProject, collectionType }, 'Failed to search source project')
+      return []
+    }
+  }
+}

package/src/diagnostics/index.ts

@@ -0,0 +1,123 @@
+import os from 'os'
+import fs from 'fs/promises'
+import { loadConfig } from '@/config'
+import { resolveHomePath } from '@/config/home'
+import { createLogger } from '@/utils/logger'
+
+export class DiagnosticTool {
+  private logger: any
+
+  constructor(logger: any) {
+    this.logger = logger.child({ component: 'diagnostics' })
+  }
+
+  async run(): Promise<void> {
+    console.log('🔍 Running diagnostics...\n')
+
+    await this.printSystemInfo()
+    await this.printConfiguration()
+    await this.printRecentLogs()
+    await this.printCommonIssues()
+  }
+
+  private async printSystemInfo(): Promise<void> {
+    console.log('📊 System Information')
+    console.log('─'.repeat(50))
+    console.log(`OS: ${os.platform()} ${os.release()}`)
+    console.log(`Architecture: ${os.arch()}`)
+    console.log(`Node/Bun: ${process.version}`)
+    console.log(`Bun: ${process.versions.bun || 'Not detected'}`)
+    console.log(`Memory: ${Math.round(os.totalmem() / 1024 / 1024 / 1024)}GB total`)
+    console.log(`Free Memory: ${Math.round(os.freemem() / 1024 / 1024 / 1024)}GB`)
+    console.log(`CPUs: ${os.cpus().length}`)
+    console.log(`CWD: ${process.cwd()}`)
+    console.log()
+  }
+
+  private async printConfiguration(): Promise<void> {
+    console.log('⚙️  Configuration')
+    console.log('─'.repeat(50))
+
+    try {
+      const config = await loadConfig()
+      console.log(`Vault Path: ${config.vaultPath}`)
+      console.log(`Database Path: ${config.dbPath}`)
+      console.log(`Log Level: ${config.logLevel}`)
+      console.log(`File Watch: ${config.enableFileWatch}`)
+      console.log(`Server Name: ${config.serverName}`)
+      console.log(`Server Version: ${config.serverVersion}`)
+
+    } catch (error) {
+      console.log(`Error loading config: ${error}`)
+    }
+
+    console.log()
+  }
+
+  private async printRecentLogs(): Promise<void> {
+    console.log('📝 Recent Logs (last 20 lines)')
+    console.log('─'.repeat(50))
+
+    try {
+      const logContent = await fs.readFile(resolveHomePath('./logs/claude-brain.log'), 'utf-8')
+      const lines = logContent.split('\n').filter(l => l.trim())
+      const recentLines = lines.slice(-20)
+
+      for (const line of recentLines) {
+        console.log(line)
+      }
+
+    } catch (error) {
+      console.log('No logs found or unable to read logs')
+    }
+
+    console.log()
+  }
+
+  private async printCommonIssues(): Promise<void> {
+    console.log('💡 Common Issues & Solutions')
+    console.log('─'.repeat(50))
+
+    const issues = [
+      {
+        symptom: 'MCP server not found in Claude Code',
+        solution: 'Check Claude Code config file has correct absolute path'
+      },
+      {
+        symptom: 'Vault path not found',
+        solution: 'Verify VAULT_PATH in .env points to valid Obsidian vault'
+      },
+      {
+        symptom: 'Embeddings fail',
+        solution: 'Check internet connection (first-time model download)'
+      },
+      {
+        symptom: 'Tools return stubs',
+        solution: 'Rebuild with: bun run build'
+      },
+      {
+        symptom: 'No projects found',
+        solution: 'Create project directory: Projects/your-project/'
+      }
+    ]
+
+    for (const issue of issues) {
+      console.log(`\n❓ ${issue.symptom}`)
+      console.log(`   💡 ${issue.solution}`)
+    }
+
+    console.log('\n\n📚 For more help, check the documentation or logs.\n')
+  }
+}
+
+export async function runDiagnostics() {
+  const logger = createLogger('info', resolveHomePath('./logs/diagnostics.log'))
+  const tool = new DiagnosticTool(logger)
+
+  try {
+    await tool.run()
+  } catch (error) {
+    console.error('❌ Diagnostics failed:', error)
+    process.exit(1)
+  }
+}