claude-brain 0.5.0 → 0.8.0

package/src/packs/types.ts

@@ -0,0 +1,81 @@
+/**
+ * Phase 18: Knowledge Pack Types & Schemas
+ * Defines the format for pre-seeded knowledge packs
+ */
+
+import { z } from 'zod'
+
+/** Valid entry types in a knowledge pack */
+export const PackEntryTypeSchema = z.enum([
+  'pattern',
+  'anti-pattern',
+  'best-practice',
+  'common-issue',
+  'decision-template'
+])
+
+export type PackEntryType = z.infer<typeof PackEntryTypeSchema>
+
+/** A single entry in a knowledge pack */
+export const PackEntrySchema = z.object({
+  type: PackEntryTypeSchema,
+  category: z.string().min(1),
+  title: z.string().min(1),
+  content: z.string().min(1),
+  confidence: z.number().min(0).max(1).default(0.85),
+  tags: z.array(z.string()).default([]),
+  example: z.string().optional()
+})
+
+export type PackEntry = z.infer<typeof PackEntrySchema>
+
+/** A complete knowledge pack with metadata */
+export const KnowledgePackSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  version: z.string().regex(/^\d+\.\d+\.\d+$/, 'Version must be semver'),
+  stack: z.array(z.string()).min(1),
+  description: z.string().min(1),
+  author: z.string().default('claude-brain'),
+  entries: z.array(PackEntrySchema).min(1),
+  metadata: z.record(z.string(), z.unknown()).optional()
+})
+
+export type KnowledgePack = z.infer<typeof KnowledgePackSchema>
+
+/** Tracks which packs have been loaded for a project */
+export interface PackManifestEntry {
+  packId: string
+  version: string
+  entriesLoaded: number
+  loadedAt: string
+}
+
+export interface PackManifest {
+  project: string
+  packs: PackManifestEntry[]
+  lastUpdated: string
+}
+
+/** Result of loading packs for a project */
+export interface PackLoadResult {
+  packsLoaded: number
+  entriesLoaded: number
+  packDetails: Array<{
+    packId: string
+    name: string
+    entriesLoaded: number
+  }>
+  skipped: Array<{
+    packId: string
+    reason: string
+  }>
+}
+
+/** Maps pack entry types to the storage pattern_type values */
+export const ENTRY_TYPE_TO_PATTERN_TYPE: Record<string, 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'> = {
+  'pattern': 'solution',
+  'anti-pattern': 'anti-pattern',
+  'best-practice': 'best-practice',
+  'common-issue': 'common-issue'
+}

package/src/routing/entity-extractor.ts

@@ -0,0 +1,410 @@
+/**
+ * Brain Entity Extractor
+ * Phase 16: Extracts structured data from natural language messages
+ * for the unified brain() tool routing
+ */
+
+import { getVaultService, isServicesInitialized } from '@/server/services'
+
+// Reuse phrase lists from decision detector
+const DECISION_PHRASES = [
+  'i recommend',
+  'you should use',
+  'the best approach',
+  'i suggest',
+  'better to use',
+  'prefer using',
+  'go with',
+  'choose',
+  'instead of',
+  'the right choice',
+  'decided to',
+  "let's use",
+  'we will use',
+  'the solution is',
+  'implement using',
+  'going with',
+  'switching to',
+  'adopting',
+  'we chose',
+  'the plan is to'
+]
+
+const REASONING_PHRASES = [
+  'because',
+  'since',
+  'due to',
+  'as it',
+  'which provides',
+  'this allows',
+  'this ensures',
+  'given that',
+  'considering',
+  'the reason is',
+  'this way'
+]
+
+const ALTERNATIVE_PHRASES = [
+  'instead of',
+  'rather than',
+  'over',
+  ' vs ',
+  'compared to',
+  'unlike',
+  'as opposed to'
+]
+
+// Compact tech dictionary for entity extraction (most common technologies)
+// Full dictionary is in knowledge/entity-extractor.ts — we use a subset for speed
+const COMMON_TECH: Set<string> = new Set([
+  'typescript', 'javascript', 'python', 'rust', 'go', 'java', 'ruby', 'php', 'swift', 'kotlin',
+  'react', 'vue', 'angular', 'svelte', 'nextjs', 'nuxt', 'remix', 'astro', 'solid',
+  'express', 'fastify', 'hono', 'nestjs', 'django', 'flask', 'fastapi', 'rails', 'spring',
+  'mongodb', 'redis', 'postgresql', 'postgres', 'mysql', 'sqlite', 'dynamodb', 'firebase', 'supabase',
+  'prisma', 'drizzle', 'typeorm', 'sequelize', 'chromadb', 'pinecone',
+  'docker', 'kubernetes', 'aws', 'gcp', 'azure', 'vercel', 'netlify',
+  'webpack', 'vite', 'esbuild', 'bun', 'deno', 'node', 'npm', 'yarn', 'pnpm',
+  'jest', 'vitest', 'cypress', 'playwright',
+  'tailwind', 'bootstrap', 'zod', 'trpc', 'graphql', 'rest',
+  'jwt', 'oauth', 'openai', 'anthropic', 'langchain',
+  'git', 'github', 'gitlab', 'eslint', 'prettier',
+  'zustand', 'redux', 'pinia', 'mobx', 'jotai', 'recoil',
+  'storybook', 'turborepo', 'nx',
+  'microservices', 'serverless', 'monolith', 'ssr', 'ssg', 'spa', 'pwa', 'mcp', 'rag'
+])
+
+// Aliases for common tech names
+const TECH_ALIASES: Record<string, string> = {
+  'ts': 'typescript', 'js': 'javascript', 'py': 'python',
+  'react.js': 'react', 'reactjs': 'react', 'vue.js': 'vue', 'vuejs': 'vue',
+  'next.js': 'nextjs', 'nuxt.js': 'nuxt', 'nest.js': 'nestjs',
+  'express.js': 'express', 'node.js': 'node', 'nodejs': 'node',
+  'mongo': 'mongodb', 'pg': 'postgresql', 'k8s': 'kubernetes',
+  'tailwindcss': 'tailwind', 'tailwind-css': 'tailwind',
+  'gql': 'graphql', 'golang': 'go',
+}
+
+export interface BrainExtractedEntities {
+  project?: string
+  technologies: string[]
+  decision?: string
+  reasoning?: string
+  alternatives?: string
+  topic?: string
+  completedTask?: string
+  nextSteps?: string
+  original?: string
+  correction?: string
+  patternType?: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
+}
+
+export class BrainEntityExtractor {
+  /**
+   * Extract all entities from a natural language message
+   */
+  async extract(message: string, knownProject?: string): Promise<BrainExtractedEntities> {
+    const entities: BrainExtractedEntities = {
+      technologies: []
+    }
+
+    // Use provided project or try to detect from message
+    entities.project = knownProject || await this.extractProject(message)
+    entities.technologies = this.extractTechnologies(message)
+    entities.topic = this.extractTopic(message)
+
+    // Extract decision components if present
+    const decisionParts = this.extractDecision(message)
+    if (decisionParts) {
+      entities.decision = decisionParts.decision
+      entities.reasoning = decisionParts.reasoning
+      entities.alternatives = decisionParts.alternatives
+    }
+
+    // Extract progress components
+    const progress = this.extractProgress(message)
+    if (progress) {
+      entities.completedTask = progress.completedTask
+      entities.nextSteps = progress.nextSteps
+    }
+
+    // Extract correction components
+    const correction = this.extractCorrection(message)
+    if (correction) {
+      entities.original = correction.original
+      entities.correction = correction.correction
+    }
+
+    // Extract pattern type
+    entities.patternType = this.extractPatternType(message)
+
+    return entities
+  }
+
+  /**
+   * Extract project name from message
+   */
+  private async extractProject(message: string): Promise<string | undefined> {
+    const lower = message.toLowerCase()
+
+    // Pattern: "in project X", "for project X", "on project X"
+    const projectPatterns = [
+      /(?:in|for|on)\s+(?:the\s+)?project\s+["']?([a-z0-9][a-z0-9-]*[a-z0-9])["']?/i,
+      /project\s*:\s*["']?([a-z0-9][a-z0-9-]*[a-z0-9])["']?/i,
+      /(?:in|for|on)\s+["']?([a-z0-9][a-z0-9-]*[a-z0-9])["']?\s+project/i,
+      // "working on X", "starting X", "resuming X"
+      /(?:working\s+on|starting|resuming|picking\s+up)\s+(?:the\s+)?["']?([a-z0-9][a-z0-9-]*[a-z0-9])["']?/i,
+    ]
+
+    for (const pattern of projectPatterns) {
+      const match = message.match(pattern)
+      if (match && match[1]) {
+        const candidate = match[1].toLowerCase()
+        // Filter out common false positives
+        if (!COMMON_TECH.has(candidate) && candidate.length > 1 && candidate.length < 50) {
+          return candidate
+        }
+      }
+    }
+
+    // Try to match against known projects via vault service
+    if (isServicesInitialized()) {
+      try {
+        const vault = getVaultService()
+        const projects = await vault.listProjects()
+        for (const project of projects) {
+          if (lower.includes(project.toLowerCase())) {
+            return project
+          }
+        }
+      } catch {
+        // Vault service not available, skip project matching
+      }
+    }
+
+    return undefined
+  }
+
+  /**
+   * Extract technology mentions
+   */
+  private extractTechnologies(message: string): string[] {
+    const lower = message.toLowerCase()
+    const words = lower.split(/[\s,;:()[\]{}"'`|/\\]+/)
+    const found = new Set<string>()
+
+    for (const word of words) {
+      const cleaned = word.replace(/^[^a-z0-9]+|[^a-z0-9]+$/g, '')
+      if (cleaned.length < 2) continue
+
+      // Direct match
+      if (COMMON_TECH.has(cleaned)) {
+        found.add(cleaned)
+        continue
+      }
+
+      // Alias match
+      const alias = TECH_ALIASES[cleaned]
+      if (alias) {
+        found.add(alias)
+      }
+    }
+
+    // Check multi-word aliases
+    for (const [alias, normalized] of Object.entries(TECH_ALIASES)) {
+      if (alias.includes('.') || alias.includes('-')) {
+        if (lower.includes(alias)) {
+          found.add(normalized)
+        }
+      }
+    }
+
+    return Array.from(found)
+  }
+
+  /**
+   * Extract decision, reasoning, and alternatives
+   */
+  private extractDecision(message: string): { decision?: string; reasoning?: string; alternatives?: string } | null {
+    const lower = message.toLowerCase()
+
+    const hasDecision = DECISION_PHRASES.some(p => lower.includes(p))
+    if (!hasDecision) return null
+
+    // Find the decision phrase and extract text after it
+    let decision: string | undefined
+    for (const phrase of DECISION_PHRASES) {
+      const index = lower.indexOf(phrase)
+      if (index !== -1) {
+        const afterPhrase = message.substring(index + phrase.length).trim()
+        // Take until reasoning or sentence end
+        const endIndex = this.findClauseEnd(afterPhrase, REASONING_PHRASES)
+        decision = afterPhrase.substring(0, endIndex).trim()
+        if (decision.length > 5) break
+      }
+    }
+
+    // Extract reasoning
+    let reasoning: string | undefined
+    for (const phrase of REASONING_PHRASES) {
+      const index = lower.indexOf(phrase)
+      if (index !== -1) {
+        const afterPhrase = message.substring(index).trim()
+        const endIndex = Math.min(afterPhrase.length, 300)
+        const sentenceEnd = afterPhrase.search(/\n\n/)
+        reasoning = afterPhrase.substring(0, sentenceEnd !== -1 ? sentenceEnd : endIndex).trim()
+        if (reasoning.length > 10) break
+      }
+    }
+
+    // Extract alternatives
+    let alternatives: string | undefined
+    for (const phrase of ALTERNATIVE_PHRASES) {
+      const index = lower.indexOf(phrase)
+      if (index !== -1) {
+        const afterPhrase = message.substring(index + phrase.length).trim()
+        const endMatch = afterPhrase.match(/[.!?\n]/)
+        const endIndex = endMatch ? endMatch.index! + 1 : Math.min(afterPhrase.length, 150)
+        alternatives = afterPhrase.substring(0, endIndex).trim()
+        if (alternatives.length > 3) break
+      }
+    }
+
+    if (!decision && !reasoning) return null
+
+    return { decision, reasoning, alternatives }
+  }
+
+  /**
+   * Extract progress info: completed task and next steps
+   */
+  private extractProgress(message: string): { completedTask?: string; nextSteps?: string } | null {
+    const completedPatterns = [
+      /(?:finished|completed|done with|implemented|built|created|added|fixed|resolved|shipped)\s+(.+?)(?:\.|,\s*next|$)/i,
+    ]
+
+    const nextPatterns = [
+      /(?:next\s+(?:is|step|up|i'll|we'll|will\s+be)?|then\s+(?:i'll|we'll|will)|moving\s+(?:on\s+)?to)\s+(.+?)(?:\.|$)/i,
+    ]
+
+    let completedTask: string | undefined
+    let nextSteps: string | undefined
+
+    for (const pattern of completedPatterns) {
+      const match = message.match(pattern)
+      if (match && match[1] && match[1].length > 3) {
+        completedTask = match[1].trim()
+        break
+      }
+    }
+
+    for (const pattern of nextPatterns) {
+      const match = message.match(pattern)
+      if (match && match[1] && match[1].length > 3) {
+        nextSteps = match[1].trim()
+        break
+      }
+    }
+
+    if (!completedTask) return null
+    return { completedTask, nextSteps }
+  }
+
+  /**
+   * Extract correction: original mistake and what should have been done
+   */
+  private extractCorrection(message: string): { original?: string; correction?: string } | null {
+    const lower = message.toLowerCase()
+
+    const correctionIndicators = [
+      'the bug was', 'the issue was', 'the problem was', 'mistake was',
+      'should have', 'should not have', "shouldn't have",
+      'lesson learned', "don't use", 'avoid using', 'never use',
+      'the fix is', 'the fix was', 'fixed by', 'solved by'
+    ]
+
+    const hasCorrection = correctionIndicators.some(p => lower.includes(p))
+    if (!hasCorrection) return null
+
+    // Extract the original problem
+    let original: string | undefined
+    const problemPatterns = [
+      /(?:the\s+(?:bug|issue|problem|mistake)\s+was)\s+(.+?)(?:\.|,|;|$)/i,
+      /(?:should\s+(?:have|not\s+have)|shouldn't\s+have)\s+(.+?)(?:\.|,|;|$)/i
+    ]
+
+    for (const pattern of problemPatterns) {
+      const match = message.match(pattern)
+      if (match && match[1] && match[1].length > 3) {
+        original = match[1].trim()
+        break
+      }
+    }
+
+    // Extract the correction
+    let correction: string | undefined
+    const fixPatterns = [
+      /(?:the\s+fix\s+(?:is|was)|fixed\s+by|solved\s+by|instead\s+(?:should|use))\s+(.+?)(?:\.|,|;|$)/i,
+      /(?:don't\s+use|avoid\s+using|never\s+use)\s+(.+?)(?:\.|,|;|$)/i
+    ]
+
+    for (const pattern of fixPatterns) {
+      const match = message.match(pattern)
+      if (match && match[1] && match[1].length > 3) {
+        correction = match[1].trim()
+        break
+      }
+    }
+
+    if (!original && !correction) return null
+    return { original: original || message.slice(0, 200), correction }
+  }
+
+  /**
+   * Extract pattern type from message
+   */
+  private extractPatternType(message: string): BrainExtractedEntities['patternType'] {
+    const lower = message.toLowerCase()
+    if (lower.includes('anti-pattern') || lower.includes('antipattern')) return 'anti-pattern'
+    if (lower.includes('best practice') || lower.includes('best-practice')) return 'best-practice'
+    if (lower.includes('common issue') || lower.includes('common-issue') || lower.includes('common problem')) return 'common-issue'
+    if (lower.includes('pattern') || lower.includes('reusable solution') || lower.includes('reusable approach')) return 'solution'
+    return undefined
+  }
+
+  /**
+   * Extract topic from message (main subject without noise words)
+   */
+  private extractTopic(message: string): string | undefined {
+    // For short messages, the whole thing is the topic
+    if (message.length < 80) {
+      const cleaned = message.replace(/[?.!]+$/, '').trim()
+      if (cleaned.length > 3) return cleaned
+    }
+
+    // For longer messages, extract the first meaningful clause
+    const sentences = message.split(/[.!?\n]+/).filter(s => s.trim().length > 3)
+    const first = sentences[0]
+    if (first) {
+      return first.trim().slice(0, 200)
+    }
+
+    return undefined
+  }
+
+  /**
+   * Find where a clause ends (at a reasoning phrase or sentence boundary)
+   */
+  private findClauseEnd(text: string, stopPhrases: string[]): number {
+    const lower = text.toLowerCase()
+
+    const phraseStart = stopPhrases.reduce((min, phrase) => {
+      const idx = lower.indexOf(phrase)
+      return idx !== -1 ? Math.min(min, idx) : min
+    }, text.length)
+
+    const sentenceEnd = text.search(/[.!?\n]/)
+    const end = sentenceEnd !== -1 ? sentenceEnd : text.length
+
+    return Math.min(phraseStart, end, 200)
+  }
+}