claude-brain 0.17.13 → 0.22.0

package/src/setup/index.ts

@@ -1,14 +1,9 @@
-import { createLogger } from '@/utils/logger'
-import { resolveHomePath } from '@/config/home'
 import { ensureHomeDirectory } from '@/cli/auto-setup'
-import { SetupWizard } from './wizard'
-import { renderBanner, typewrite, transition, box, errorText, theme } from '@/cli/ui/index.js'
+import { renderBanner, theme } from '@/cli/ui/index.js'
 import { readFileSync } from 'node:fs'
 import { resolve, dirname } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
-export * from './wizard'
-
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
 const PACKAGE_ROOT = resolve(__dirname, '..', '..')
@@ -22,27 +17,22 @@ function getVersion(): string {
   }
 }
 
+/**
+ * Phase 30: Zero-config setup — no wizard, no prompts.
+ * Just ensures the home directory exists with sensible defaults.
+ */
 export async function runSetup() {
-  ensureHomeDirectory()
-
   const version = getVersion()
   console.log()
   console.log(renderBanner(version))
   console.log()
 
-  await typewrite(theme.dim('Welcome! Let\'s configure Claude Brain for your system.'))
-  await transition(400)
-
-  const logger = createLogger('info', resolveHomePath('./logs/setup.log'))
-
-  try {
-    const wizard = new SetupWizard(logger)
-    const answers = await wizard.run()
-    await wizard.applyConfiguration(answers)
+  ensureHomeDirectory()
 
-  } catch (error) {
-    console.log()
-    console.log(box(errorText(`Setup failed: ${error instanceof Error ? error.message : String(error)}`), 'Error'))
-    process.exit(1)
-  }
+  console.log()
+  console.log(theme.bold('Setup complete! No configuration needed.'))
+  console.log()
+  console.log(`  ${theme.primary('Next:')} ${theme.dim('claude-brain start')}`)
+  console.log(`  ${theme.dim('ChromaDB is optional — SQLite FTS5 works out of the box.')}`)
+  console.log()
 }

package/src/tools/schemas.ts

@@ -590,7 +590,7 @@ export const TOOLS = {
    */
   BRAIN: {
     name: 'brain',
-    description: 'Your persistent memory. Tell it decisions, ask it questions, or update/delete past notes. Most context is captured automatically — only call this for intentional storage or recall.',
+    description: 'Your persistent memory. Tell it decisions, ask it questions, or update/delete past notes. Most context is captured automatically — only call this for intentional storage or recall. Search returns compact summaries — use brain("details {ID}") for full context.',
     inputSchema: {
       type: 'object' as const,
       properties: {

package/src/intelligence/cross-project/affinity.ts

@@ -1,159 +0,0 @@
-/**
- * Project Affinity
- * Computes similarity between projects based on decisions, patterns, and tech stack
- */
-
-import type { Logger } from 'pino'
-import type { CollectionManager } from '@/memory/chroma/collection-manager'
-import type { EmbeddingProvider } from '@/memory/chroma/embeddings'
-
-export interface ProjectAffinity {
-  projectA: string
-  projectB: string
-  similarity: number
-  sharedTopics: string[]
-  sharedTechnologies: string[]
-  decisionOverlap: number
-}
-
-export class AffinityCalculator {
-  private logger: Logger
-  private collections: CollectionManager
-  constructor(logger: Logger, collections: CollectionManager, _embeddings?: EmbeddingProvider) {
-    this.logger = logger.child({ component: 'affinity-calculator' })
-    this.collections = collections
-  }
-
-  /**
-   * Calculate affinity between all pairs of projects
-   */
-  async calculateAffinities(options: {
-    minDecisions?: number
-  } = {}): Promise<ProjectAffinity[]> {
-    const { minDecisions = 2 } = options
-
-    // Get all decisions grouped by project
-    const byProject = await this.getDecisionsByProject()
-
-    // Filter out projects with too few decisions
-    const projects = Array.from(byProject.entries())
-      .filter(([_, decisions]) => decisions.length >= minDecisions)
-
-    const affinities: ProjectAffinity[] = []
-
-    // Compare all pairs
-    for (let i = 0; i < projects.length; i++) {
-      for (let j = i + 1; j < projects.length; j++) {
-        const [projectA, decisionsA] = projects[i]!
-        const [projectB, decisionsB] = projects[j]!
-
-        const affinity = this.compareProjects(projectA, decisionsA, projectB, decisionsB)
-        if (affinity.similarity > 0.1) {
-          affinities.push(affinity)
-        }
-      }
-    }
-
-    return affinities.sort((a, b) => b.similarity - a.similarity)
-  }
-
-  /**
-   * Find most similar projects to a given project
-   */
-  async findSimilarProjects(project: string, limit: number = 5): Promise<ProjectAffinity[]> {
-    const affinities = await this.calculateAffinities()
-
-    return affinities
-      .filter(a => a.projectA === project || a.projectB === project)
-      .sort((a, b) => b.similarity - a.similarity)
-      .slice(0, limit)
-  }
-
-  private async getDecisionsByProject(): Promise<Map<string, Array<{ id: string; content: string; tags: string[] }>>> {
-    try {
-      const collection = await this.collections.getDecisions()
-
-      const results = await collection.get({
-        include: ['documents', 'metadatas']
-      })
-
-      const byProject = new Map<string, Array<{ id: string; content: string; tags: string[] }>>()
-
-      for (let i = 0; i < results.ids.length; i++) {
-        const project = (results.metadatas![i] as any)?.project || ''
-        if (!project) continue
-
-        if (!byProject.has(project)) byProject.set(project, [])
-
-        byProject.get(project)!.push({
-          id: results.ids[i]!,
-          content: results.documents![i] as string || '',
-          tags: String((results.metadatas![i] as any)?.tags || '').split(',').filter(t => t.trim())
-        })
-      }
-
-      return byProject
-    } catch (error) {
-      this.logger.warn({ error }, 'Failed to get decisions by project')
-      return new Map()
-    }
-  }
-
-  private compareProjects(
-    projectA: string,
-    decisionsA: Array<{ id: string; content: string; tags: string[] }>,
-    projectB: string,
-    decisionsB: Array<{ id: string; content: string; tags: string[] }>
-  ): ProjectAffinity {
-    // Term-based similarity
-    const termsA = this.extractAllTerms(decisionsA)
-    const termsB = this.extractAllTerms(decisionsB)
-
-    const sharedTopics = Array.from(termsA).filter(t => termsB.has(t))
-    const allTopics = new Set([...termsA, ...termsB])
-
-    const topicSimilarity = allTopics.size > 0 ? sharedTopics.length / allTopics.size : 0
-
-    // Tag-based similarity
-    const tagsA = new Set(decisionsA.flatMap(d => d.tags))
-    const tagsB = new Set(decisionsB.flatMap(d => d.tags))
-
-    const sharedTags = Array.from(tagsA).filter(t => tagsB.has(t))
-    const allTags = new Set([...tagsA, ...tagsB])
-    const tagSimilarity = allTags.size > 0 ? sharedTags.length / allTags.size : 0
-
-    // Combined similarity
-    const similarity = topicSimilarity * 0.7 + tagSimilarity * 0.3
-
-    return {
-      projectA,
-      projectB,
-      similarity,
-      sharedTopics: sharedTopics.slice(0, 20),
-      sharedTechnologies: sharedTags.slice(0, 10),
-      decisionOverlap: sharedTopics.length
-    }
-  }
-
-  private extractAllTerms(decisions: Array<{ content: string }>): Set<string> {
-    const terms = new Set<string>()
-    const stopWords = new Set([
-      'the', 'and', 'for', 'are', 'but', 'not', 'all', 'can', 'was',
-      'has', 'had', 'been', 'have', 'with', 'this', 'that', 'from',
-      'use', 'using', 'used', 'will', 'would', 'should', 'also',
-      'decision', 'decided', 'recommend', 'instead', 'because',
-      'project', 'context', 'reasoning', 'about', 'which', 'when'
-    ])
-
-    for (const d of decisions) {
-      const words = d.content.toLowerCase().replace(/[^a-z0-9\s]/g, ' ').split(/\s+/)
-      for (const w of words) {
-        if (w.length > 3 && !stopWords.has(w)) {
-          terms.add(w)
-        }
-      }
-    }
-
-    return terms
-  }
-}

package/src/intelligence/cross-project/transfer.ts

@@ -1,201 +0,0 @@
-/**
- * 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/intelligence/prediction/context-anticipator.ts

@@ -1,198 +0,0 @@
-/**
- * Context Anticipator
- * Anticipates what context will be needed based on current activity
- */
-
-import type { Logger } from 'pino'
-import type { CollectionManager } from '@/memory/chroma/collection-manager'
-import type { EmbeddingProvider } from '@/memory/chroma/embeddings'
-
-export interface AnticipatedContext {
-  topic: string
-  relevance: number
-  relatedDecisions: number
-  suggestedQueries: string[]
-}
-
-export class ContextAnticipator {
-  private logger: Logger
-  private collections: CollectionManager
-  private embeddings?: EmbeddingProvider
-  private recentTopics: Array<{ topic: string; timestamp: number }> = []
-
-  constructor(logger: Logger, collections: CollectionManager, embeddings?: EmbeddingProvider) {
-    this.logger = logger.child({ component: 'context-anticipator' })
-    this.collections = collections
-    this.embeddings = embeddings
-  }
-
-  /**
-   * Record a topic being worked on for anticipation
-   */
-  recordActivity(topic: string): void {
-    this.recentTopics.push({ topic, timestamp: Date.now() })
-    // Keep last 50 topics
-    if (this.recentTopics.length > 50) {
-      this.recentTopics = this.recentTopics.slice(-50)
-    }
-  }
-
-  /**
-   * Anticipate what context might be needed next
-   */
-  async anticipate(currentTask: string, options: {
-    project?: string
-    limit?: number
-  } = {}): Promise<AnticipatedContext[]> {
-    const { project, limit = 5 } = options
-
-    // Get patterns of what typically follows similar tasks
-    const followUpTopics = await this.findFollowUpPatterns(currentTask, project)
-
-    // Get related but not-yet-accessed topics
-    const relatedTopics = await this.findRelatedTopics(currentTask, project)
-
-    // Merge and rank
-    const merged = new Map<string, AnticipatedContext>()
-
-    for (const t of followUpTopics) {
-      merged.set(t.topic, t)
-    }
-
-    for (const t of relatedTopics) {
-      if (merged.has(t.topic)) {
-        const existing = merged.get(t.topic)!
-        existing.relevance = Math.max(existing.relevance, t.relevance)
-        existing.relatedDecisions = Math.max(existing.relatedDecisions, t.relatedDecisions)
-      } else {
-        merged.set(t.topic, t)
-      }
-    }
-
-    return Array.from(merged.values())
-      .sort((a, b) => b.relevance - a.relevance)
-      .slice(0, limit)
-  }
-
-  private async findFollowUpPatterns(
-    currentTask: string,
-    project?: string
-  ): Promise<AnticipatedContext[]> {
-    try {
-      const collection = await this.collections.getDecisions()
-
-      const where: any = project ? { project: { $eq: project } } : undefined
-
-      let results: any
-
-      if (this.embeddings) {
-        const embedding = await this.embeddings.generate(currentTask)
-        results = await collection.query({
-          queryEmbeddings: [embedding],
-          nResults: 10,
-          where,
-          include: ['documents', 'metadatas', 'distances']
-        })
-      } else {
-        results = await collection.query({
-          queryTexts: [currentTask],
-          nResults: 10,
-          where,
-          include: ['documents', 'metadatas', 'distances']
-        })
-      }
-
-      if (!results.ids || !results.ids[0]) return []
-
-      // Extract unique topics from the results
-      const topicCounts = new Map<string, { count: number; similarity: number }>()
-      const metadatas = results.metadatas?.[0] || []
-      const distances = results.distances?.[0] || []
-
-      for (let i = 0; i < metadatas.length; i++) {
-        const tags = String((metadatas[i] as any)?.tags || '').split(',').filter((t: string) => t.trim())
-        const similarity = 1 - (distances[i] || 0)
-
-        for (const tag of tags) {
-          const trimmed = tag.trim().toLowerCase()
-          if (!trimmed) continue
-
-          const existing = topicCounts.get(trimmed)
-          if (existing) {
-            existing.count++
-            existing.similarity = Math.max(existing.similarity, similarity)
-          } else {
-            topicCounts.set(trimmed, { count: 1, similarity })
-          }
-        }
-      }
-
-      return Array.from(topicCounts.entries()).map(([topic, data]) => ({
-        topic,
-        relevance: data.similarity * (1 + Math.log(data.count + 1) / 5),
-        relatedDecisions: data.count,
-        suggestedQueries: [`What decisions were made about ${topic}?`, `Show patterns for ${topic}`]
-      }))
-    } catch (error) {
-      this.logger.debug({ error }, 'Failed to find follow-up patterns')
-      return []
-    }
-  }
-
-  private async findRelatedTopics(
-    currentTask: string,
-    project?: string
-  ): Promise<AnticipatedContext[]> {
-    try {
-      const collection = await this.collections.getPatterns()
-
-      const where: any = project ? { project: { $eq: project } } : undefined
-
-      let results: any
-
-      if (this.embeddings) {
-        const embedding = await this.embeddings.generate(currentTask)
-        results = await collection.query({
-          queryEmbeddings: [embedding],
-          nResults: 5,
-          where,
-          include: ['documents', 'metadatas', 'distances']
-        })
-      } else {
-        results = await collection.query({
-          queryTexts: [currentTask],
-          nResults: 5,
-          where,
-          include: ['documents', 'metadatas', 'distances']
-        })
-      }
-
-      if (!results.ids || !results.ids[0]) return []
-
-      const topics: AnticipatedContext[] = []
-      const documents = results.documents?.[0] || []
-      const metadatas = results.metadatas?.[0] || []
-      const distances = results.distances?.[0] || []
-
-      for (let i = 0; i < documents.length; i++) {
-        const similarity = 1 - (distances[i] || 0)
-        if (similarity < 0.3) continue
-
-        const content = (documents[i] || '').slice(0, 100)
-        const patternType = (metadatas[i] as any)?.pattern_type || 'unknown'
-
-        topics.push({
-          topic: `${patternType}: ${content}`,
-          relevance: similarity,
-          relatedDecisions: 1,
-          suggestedQueries: [`Show ${patternType} patterns related to this`]
-        })
-      }
-
-      return topics
-    } catch (error) {
-      this.logger.debug({ error }, 'Failed to find related topics')
-      return []
-    }
-  }
-}