claude-brain 0.3.0

package/src/context/types.ts

@@ -0,0 +1,252 @@
+/**
+ * Context Management System Types
+ * Phase 5: Intelligent context assembly for Claude Brain
+ */
+
+/**
+ * A single context layer with priority
+ */
+export interface ContextLayer {
+  level: 'global' | 'project' | 'file' | 'function'
+  priority: number
+  content: Record<string, unknown>
+  metadata: ContextMetadata
+}
+
+/**
+ * Metadata for context entries
+ */
+export interface ContextMetadata {
+  source: string
+  timestamp: Date
+  version: number
+  tags: string[]
+  relevance?: number
+}
+
+/**
+ * Global context shared across all projects
+ */
+export interface GlobalContext {
+  standards: CodeStandards
+  patterns: DesignPatterns
+  bestPractices: BestPractices
+  commonPitfalls: string[]
+}
+
+/**
+ * Project-specific context
+ */
+export interface ProjectContext {
+  name: string
+  description: string
+  techStack: string[]
+  architecture: string
+  goals: string[]
+  constraints: string[]
+  currentPhase: string
+  progress: ProgressState
+  decisions: DecisionSummary[]
+  standards: CodeStandards
+  teamPreferences: Record<string, unknown>
+}
+
+/**
+ * File-level context
+ */
+export interface FileContext {
+  path: string
+  purpose: string
+  dependencies: string[]
+  relatedFiles: string[]
+  lastModified: Date
+}
+
+/**
+ * Complete code standards definition
+ */
+export interface CodeStandards {
+  languages: LanguageStandards[]
+  frameworks: FrameworkStandards[]
+  naming: NamingConventions
+  formatting: FormattingRules
+  testing: TestingStandards
+  documentation: DocumentationStandards
+  security: SecurityStandards
+}
+
+/**
+ * Language-specific coding standards
+ */
+export interface LanguageStandards {
+  language: string
+  version: string
+  style: string
+  linting: Record<string, unknown>
+  conventions: string[]
+  antiPatterns: string[]
+}
+
+/**
+ * Framework-specific standards
+ */
+export interface FrameworkStandards {
+  framework: string
+  version: string
+  patterns: string[]
+  bestPractices: string[]
+  conventions: string[]
+}
+
+/**
+ * Project progress tracking
+ */
+export interface ProgressState {
+  currentPhase: string
+  completionPercentage: number
+  completedTasks: TaskSummary[]
+  currentTasks: TaskSummary[]
+  nextSteps: string[]
+  blockers: Blocker[]
+  velocity: number
+}
+
+/**
+ * Task summary for progress tracking
+ */
+export interface TaskSummary {
+  id: string
+  title: string
+  status: string
+  completedAt?: Date
+}
+
+/**
+ * Project blocker
+ */
+export interface Blocker {
+  description: string
+  severity: 'low' | 'medium' | 'high' | 'critical'
+  since: Date
+  owner?: string
+}
+
+/**
+ * Decision summary for context
+ */
+export interface DecisionSummary {
+  id: string
+  title: string
+  decision: string
+  date: Date
+  impact: string
+}
+
+/**
+ * Completely assembled context for a project
+ */
+export interface AssembledContext {
+  project: ProjectContext
+  global: GlobalContext
+  memories: MemoryContext[]
+  progress: ProgressState
+  standards: CodeStandards
+  metadata: {
+    assembledAt: Date
+    tokenCount: number
+    sources: string[]
+  }
+}
+
+/**
+ * Memory context with relevance score
+ */
+export interface MemoryContext {
+  content: string
+  similarity: number
+  date: Date
+  tags: string[]
+}
+
+/**
+ * Options for context assembly
+ */
+export interface ContextOptions {
+  includeMemories: boolean
+  includeProgress: boolean
+  includeStandards: boolean
+  maxTokens?: number
+  relevanceThreshold?: number
+}
+
+/**
+ * Design patterns and their usage
+ */
+export interface DesignPatterns {
+  [patternName: string]: {
+    description: string
+    whenToUse: string[]
+    examples: string[]
+  }
+}
+
+/**
+ * Best practices organized by category
+ */
+export interface BestPractices {
+  [category: string]: string[]
+}
+
+/**
+ * Naming conventions
+ */
+export interface NamingConventions {
+  variables: string
+  functions: string
+  classes: string
+  constants: string
+  interfaces: string
+  types: string
+  files: string
+}
+
+/**
+ * Formatting rules
+ */
+export interface FormattingRules {
+  indentSize: number
+  indentStyle: 'spaces' | 'tabs'
+  maxLineLength: number
+  trailingCommas: boolean
+  semicolons: boolean
+  quotes: 'single' | 'double' | 'backtick'
+}
+
+/**
+ * Testing standards
+ */
+export interface TestingStandards {
+  framework: string
+  coverageTarget: number
+  testFilePattern: string
+  namingConvention: string
+}
+
+/**
+ * Documentation standards
+ */
+export interface DocumentationStandards {
+  jsdoc: boolean
+  readmeSections: string[]
+  apiDocs: boolean
+  inlineComments: boolean
+}
+
+/**
+ * Security standards
+ */
+export interface SecurityStandards {
+  auditCommands: string[]
+  sensitivePatterns: string[]
+  dependencyChecks: boolean
+}

package/src/context/validator.ts

@@ -0,0 +1,58 @@
+/**
+ * Context Schema Validator
+ * Validates context structures using Zod schemas
+ */
+
+import { z } from 'zod'
+
+export const ProjectContextSchema = z.object({
+  name: z.string().min(1),
+  description: z.string(),
+  techStack: z.array(z.string()),
+  architecture: z.string(),
+  goals: z.array(z.string()),
+  constraints: z.array(z.string()),
+  currentPhase: z.string(),
+  progress: z.object({
+    currentPhase: z.string(),
+    completionPercentage: z.number().min(0).max(100),
+    completedTasks: z.array(z.any()),
+    currentTasks: z.array(z.any()),
+    nextSteps: z.array(z.string()),
+    blockers: z.array(z.any()),
+    velocity: z.number()
+  }),
+  decisions: z.array(z.any()),
+  standards: z.any(),
+  teamPreferences: z.record(z.any())
+})
+
+export const CodeStandardsSchema = z.object({
+  languages: z.array(z.any()),
+  frameworks: z.array(z.any()),
+  naming: z.any(),
+  formatting: z.any(),
+  testing: z.any(),
+  documentation: z.any(),
+  security: z.any()
+})
+
+export class ContextValidator {
+  static validateProjectContext(data: unknown): boolean {
+    try {
+      ProjectContextSchema.parse(data)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  static validateCodeStandards(data: unknown): boolean {
+    try {
+      CodeStandardsSchema.parse(data)
+      return true
+    } catch {
+      return false
+    }
+  }
+}

package/src/cross-project/affinity.ts

@@ -0,0 +1,162 @@
+/**
+ * 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
+  private embeddings?: EmbeddingProvider
+
+  constructor(logger: Logger, collections: CollectionManager, embeddings?: EmbeddingProvider) {
+    this.logger = logger.child({ component: 'affinity-calculator' })
+    this.collections = collections
+    this.embeddings = embeddings
+  }
+
+  /**
+   * 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
+  }
+}