claude-brain 0.15.2 → 0.16.0

package/src/context/cache-manager.ts

@@ -1,101 +1,101 @@
-/**
- * Context Cache Manager
- * Manages cached context with intelligent invalidation
- */
-
-import type { Logger } from 'pino'
-import type { AssembledContext } from './types'
-
-interface CacheEntry {
-  context: AssembledContext
-  cachedAt: Date
-  ttl: number
-  dependencies: string[]
-}
-
-export class ContextCacheManager {
-  private cache: Map<string, CacheEntry>
-  private logger: Logger
-  private defaultTTL: number = 3600
-
-  constructor(logger: Logger) {
-    this.logger = logger.child({ component: 'context-cache' })
-    this.cache = new Map()
-  }
-
-  get(projectName: string): AssembledContext | null {
-    const entry = this.cache.get(projectName)
-
-    if (!entry) {
-      this.logger.debug({ projectName }, 'Cache miss')
-      return null
-    }
-
-    const age = Date.now() - entry.cachedAt.getTime()
-    if (age > entry.ttl * 1000) {
-      this.logger.debug({ projectName, age }, 'Cache expired')
-      this.cache.delete(projectName)
-      return null
-    }
-
-    this.logger.debug({ projectName }, 'Cache hit')
-    return entry.context
-  }
-
-  set(
-    projectName: string,
-    context: AssembledContext,
-    dependencies: string[],
-    ttl: number = this.defaultTTL
-  ): void {
-    this.cache.set(projectName, {
-      context,
-      cachedAt: new Date(),
-      ttl,
-      dependencies
-    })
-
-    this.logger.debug({ projectName, ttl }, 'Context cached')
-  }
-
-  invalidate(projectName: string): void {
-    this.cache.delete(projectName)
-    this.logger.info({ projectName }, 'Cache invalidated')
-  }
-
-  invalidateByFile(filePath: string): void {
-    let invalidatedCount = 0
-
-    for (const [projectName, entry] of this.cache) {
-      if (entry.dependencies.some(dep => filePath.includes(dep))) {
-        this.cache.delete(projectName)
-        invalidatedCount++
-      }
-    }
-
-    if (invalidatedCount > 0) {
-      this.logger.info(
-        { filePath, count: invalidatedCount },
-        'Cache invalidated by file change'
-      )
-    }
-  }
-
-  clear(): void {
-    this.cache.clear()
-    this.logger.info('All cache cleared')
-  }
-
-  getStats() {
-    const entries = Array.from(this.cache.values())
-    const now = Date.now()
-
-    return {
-      size: this.cache.size,
-      entries: Array.from(this.cache.keys()),
-      avgAge: entries.length > 0
-        ? entries.reduce((sum, e) => sum + (now - e.cachedAt.getTime()), 0) / entries.length / 1000
-        : 0
-    }
-  }
-}
+/**
+ * Context Cache Manager
+ * Manages cached context with intelligent invalidation
+ */
+
+import type { Logger } from 'pino'
+import type { AssembledContext } from './types'
+
+interface CacheEntry {
+  context: AssembledContext
+  cachedAt: Date
+  ttl: number
+  dependencies: string[]
+}
+
+export class ContextCacheManager {
+  private cache: Map<string, CacheEntry>
+  private logger: Logger
+  private defaultTTL: number = 3600
+
+  constructor(logger: Logger) {
+    this.logger = logger.child({ component: 'context-cache' })
+    this.cache = new Map()
+  }
+
+  get(projectName: string): AssembledContext | null {
+    const entry = this.cache.get(projectName)
+
+    if (!entry) {
+      this.logger.debug({ projectName }, 'Cache miss')
+      return null
+    }
+
+    const age = Date.now() - entry.cachedAt.getTime()
+    if (age > entry.ttl * 1000) {
+      this.logger.debug({ projectName, age }, 'Cache expired')
+      this.cache.delete(projectName)
+      return null
+    }
+
+    this.logger.debug({ projectName }, 'Cache hit')
+    return entry.context
+  }
+
+  set(
+    projectName: string,
+    context: AssembledContext,
+    dependencies: string[],
+    ttl: number = this.defaultTTL
+  ): void {
+    this.cache.set(projectName, {
+      context,
+      cachedAt: new Date(),
+      ttl,
+      dependencies
+    })
+
+    this.logger.debug({ projectName, ttl }, 'Context cached')
+  }
+
+  invalidate(projectName: string): void {
+    this.cache.delete(projectName)
+    this.logger.info({ projectName }, 'Cache invalidated')
+  }
+
+  invalidateByFile(filePath: string): void {
+    let invalidatedCount = 0
+
+    for (const [projectName, entry] of this.cache) {
+      if (entry.dependencies.some(dep => filePath.includes(dep))) {
+        this.cache.delete(projectName)
+        invalidatedCount++
+      }
+    }
+
+    if (invalidatedCount > 0) {
+      this.logger.info(
+        { filePath, count: invalidatedCount },
+        'Cache invalidated by file change'
+      )
+    }
+  }
+
+  clear(): void {
+    this.cache.clear()
+    this.logger.info('All cache cleared')
+  }
+
+  getStats() {
+    const entries = Array.from(this.cache.values())
+    const now = Date.now()
+
+    return {
+      size: this.cache.size,
+      entries: Array.from(this.cache.keys()),
+      avgAge: entries.length > 0
+        ? entries.reduce((sum, e) => sum + (now - e.cachedAt.getTime()), 0) / entries.length / 1000
+        : 0
+    }
+  }
+}

package/src/context/formatter.ts

@@ -1,84 +1,84 @@
-/**
- * Context Formatter
- * Formats assembled context for Claude Code consumption
- */
-
-import type { AssembledContext } from './types'
-
-export class ContextFormatter {
-  static format(context: AssembledContext): string {
-    let output = ''
-
-    output += `# Project: ${context.project.name}\n\n`
-    output += `${context.project.description}\n\n`
-
-    if (context.project.techStack.length > 0) {
-      output += `## Tech Stack\n`
-      output += context.project.techStack.map(tech => `- ${tech}`).join('\n')
-      output += '\n\n'
-    }
-
-    if (context.project.architecture) {
-      output += `## Architecture\n${context.project.architecture}\n\n`
-    }
-
-    output += `## Current Progress\n`
-    output += `**Phase:** ${context.progress.currentPhase}\n`
-    output += `**Completion:** ${context.progress.completionPercentage}%\n\n`
-
-    if (context.progress.currentTasks.length > 0) {
-      output += `**Current Tasks:**\n`
-      context.progress.currentTasks.forEach(task => {
-        output += `- ${task.title} (${task.status})\n`
-      })
-      output += '\n'
-    }
-
-    if (context.progress.nextSteps.length > 0) {
-      output += `**Next Steps:**\n`
-      context.progress.nextSteps.forEach(step => {
-        output += `- ${step}\n`
-      })
-      output += '\n'
-    }
-
-    if (context.progress.blockers.length > 0) {
-      output += `**Blockers:**\n`
-      context.progress.blockers.forEach(blocker => {
-        output += `- [${blocker.severity}] ${blocker.description}\n`
-      })
-      output += '\n'
-    }
-
-    if (context.memories.length > 0) {
-      output += `## Relevant Past Context\n\n`
-      context.memories.forEach((memory, i) => {
-        output += `### ${i + 1}. (${(memory.similarity * 100).toFixed(0)}% match)\n`
-        output += `${memory.content}\n\n`
-      })
-    }
-
-    if (context.standards.languages.length > 0) {
-      output += `## Coding Standards\n\n`
-      context.standards.languages.forEach(lang => {
-        output += `**${lang.language}:**\n`
-        if (lang.conventions.length > 0) {
-          output += `Conventions: ${lang.conventions.join(', ')}\n`
-        }
-        output += '\n'
-      })
-    }
-
-    return output
-  }
-
-  static formatJSON(context: AssembledContext): string {
-    return JSON.stringify(context, null, 2)
-  }
-
-  static formatConcise(context: AssembledContext): string {
-    return `${context.project.name} (${context.progress.currentPhase}, ${context.progress.completionPercentage}% complete)\n` +
-           `Tech: ${context.project.techStack.join(', ')}\n` +
-           `Next: ${context.progress.nextSteps.slice(0, 3).join(', ')}`
-  }
-}
+/**
+ * Context Formatter
+ * Formats assembled context for Claude Code consumption
+ */
+
+import type { AssembledContext } from './types'
+
+export class ContextFormatter {
+  static format(context: AssembledContext): string {
+    let output = ''
+
+    output += `# Project: ${context.project.name}\n\n`
+    output += `${context.project.description}\n\n`
+
+    if (context.project.techStack.length > 0) {
+      output += `## Tech Stack\n`
+      output += context.project.techStack.map(tech => `- ${tech}`).join('\n')
+      output += '\n\n'
+    }
+
+    if (context.project.architecture) {
+      output += `## Architecture\n${context.project.architecture}\n\n`
+    }
+
+    output += `## Current Progress\n`
+    output += `**Phase:** ${context.progress.currentPhase}\n`
+    output += `**Completion:** ${context.progress.completionPercentage}%\n\n`
+
+    if (context.progress.currentTasks.length > 0) {
+      output += `**Current Tasks:**\n`
+      context.progress.currentTasks.forEach(task => {
+        output += `- ${task.title} (${task.status})\n`
+      })
+      output += '\n'
+    }
+
+    if (context.progress.nextSteps.length > 0) {
+      output += `**Next Steps:**\n`
+      context.progress.nextSteps.forEach(step => {
+        output += `- ${step}\n`
+      })
+      output += '\n'
+    }
+
+    if (context.progress.blockers.length > 0) {
+      output += `**Blockers:**\n`
+      context.progress.blockers.forEach(blocker => {
+        output += `- [${blocker.severity}] ${blocker.description}\n`
+      })
+      output += '\n'
+    }
+
+    if (context.memories.length > 0) {
+      output += `## Relevant Past Context\n\n`
+      context.memories.forEach((memory, i) => {
+        output += `### ${i + 1}. (${(memory.similarity * 100).toFixed(0)}% match)\n`
+        output += `${memory.content}\n\n`
+      })
+    }
+
+    if (context.standards.languages.length > 0) {
+      output += `## Coding Standards\n\n`
+      context.standards.languages.forEach(lang => {
+        output += `**${lang.language}:**\n`
+        if (lang.conventions.length > 0) {
+          output += `Conventions: ${lang.conventions.join(', ')}\n`
+        }
+        output += '\n'
+      })
+    }
+
+    return output
+  }
+
+  static formatJSON(context: AssembledContext): string {
+    return JSON.stringify(context, null, 2)
+  }
+
+  static formatConcise(context: AssembledContext): string {
+    return `${context.project.name} (${context.progress.currentPhase}, ${context.progress.completionPercentage}% complete)\n` +
+           `Tech: ${context.project.techStack.join(', ')}\n` +
+           `Next: ${context.progress.nextSteps.slice(0, 3).join(', ')}`
+  }
+}

package/src/context/hierarchy.ts

@@ -1,85 +1,85 @@
-/**
- * Context Hierarchy Manager
- * Manages hierarchical context layers with priority-based merging
- */
-
-import type { Logger } from 'pino'
-import type { ContextLayer } from './types'
-
-export class ContextHierarchy {
-  private layers: Map<string, ContextLayer>
-  private logger: Logger
-
-  constructor(logger: Logger) {
-    this.logger = logger.child({ component: 'context-hierarchy' })
-    this.layers = new Map()
-  }
-
-  addLayer(id: string, layer: ContextLayer): void {
-    this.layers.set(id, layer)
-    this.logger.debug({ id, level: layer.level }, 'Layer added')
-  }
-
-  getLayer(id: string): ContextLayer | undefined {
-    return this.layers.get(id)
-  }
-
-  getLayersByLevel(level: ContextLayer['level']): ContextLayer[] {
-    return Array.from(this.layers.values())
-      .filter(layer => layer.level === level)
-  }
-
-  mergeLayers(layerIds: string[]): Record<string, unknown> {
-    const layers = layerIds
-      .map(id => this.layers.get(id))
-      .filter((layer): layer is ContextLayer => layer !== undefined)
-      .sort((a, b) => b.priority - a.priority)
-
-    const merged: Record<string, unknown> = {}
-
-    for (const layer of layers) {
-      Object.assign(merged, layer.content)
-    }
-
-    return merged
-  }
-
-  resolveInheritance(projectName: string): Record<string, unknown> {
-    const globalLayers = this.getLayersByLevel('global')
-    let context = this.mergeLayers(
-      globalLayers.map((_, idx) => `global-${idx}`)
-    )
-
-    const projectLayers = this.getLayersByLevel('project')
-      .filter(layer =>
-        layer.metadata.tags.includes(projectName)
-      )
-
-    const projectContext = this.mergeLayers(
-      projectLayers.map((_, idx) => `project-${idx}`)
-    )
-
-    context = { ...context, ...projectContext }
-
-    return context
-  }
-
-  clear(): void {
-    this.layers.clear()
-    this.logger.debug('All layers cleared')
-  }
-
-  getStats() {
-    const levelCounts = new Map<string, number>()
-
-    for (const layer of this.layers.values()) {
-      const count = levelCounts.get(layer.level) || 0
-      levelCounts.set(layer.level, count + 1)
-    }
-
-    return {
-      totalLayers: this.layers.size,
-      byLevel: Object.fromEntries(levelCounts)
-    }
-  }
-}
+/**
+ * Context Hierarchy Manager
+ * Manages hierarchical context layers with priority-based merging
+ */
+
+import type { Logger } from 'pino'
+import type { ContextLayer } from './types'
+
+export class ContextHierarchy {
+  private layers: Map<string, ContextLayer>
+  private logger: Logger
+
+  constructor(logger: Logger) {
+    this.logger = logger.child({ component: 'context-hierarchy' })
+    this.layers = new Map()
+  }
+
+  addLayer(id: string, layer: ContextLayer): void {
+    this.layers.set(id, layer)
+    this.logger.debug({ id, level: layer.level }, 'Layer added')
+  }
+
+  getLayer(id: string): ContextLayer | undefined {
+    return this.layers.get(id)
+  }
+
+  getLayersByLevel(level: ContextLayer['level']): ContextLayer[] {
+    return Array.from(this.layers.values())
+      .filter(layer => layer.level === level)
+  }
+
+  mergeLayers(layerIds: string[]): Record<string, unknown> {
+    const layers = layerIds
+      .map(id => this.layers.get(id))
+      .filter((layer): layer is ContextLayer => layer !== undefined)
+      .sort((a, b) => b.priority - a.priority)
+
+    const merged: Record<string, unknown> = {}
+
+    for (const layer of layers) {
+      Object.assign(merged, layer.content)
+    }
+
+    return merged
+  }
+
+  resolveInheritance(projectName: string): Record<string, unknown> {
+    const globalLayers = this.getLayersByLevel('global')
+    let context = this.mergeLayers(
+      globalLayers.map((_, idx) => `global-${idx}`)
+    )
+
+    const projectLayers = this.getLayersByLevel('project')
+      .filter(layer =>
+        layer.metadata.tags.includes(projectName)
+      )
+
+    const projectContext = this.mergeLayers(
+      projectLayers.map((_, idx) => `project-${idx}`)
+    )
+
+    context = { ...context, ...projectContext }
+
+    return context
+  }
+
+  clear(): void {
+    this.layers.clear()
+    this.logger.debug('All layers cleared')
+  }
+
+  getStats() {
+    const levelCounts = new Map<string, number>()
+
+    for (const layer of this.layers.values()) {
+      const count = levelCounts.get(layer.level) || 0
+      levelCounts.set(layer.level, count + 1)
+    }
+
+    return {
+      totalLayers: this.layers.size,
+      byLevel: Object.fromEntries(levelCounts)
+    }
+  }
+}