claude-brain 0.15.2 → 0.17.0

package/src/context/index.ts

@@ -1,83 +1,83 @@
-/**
- * Context Management System
- * Main module that combines all context components
- */
-
-import type { Logger } from 'pino'
-import type { VaultManager } from '@/vault'
-import type { MemoryManager } from '@/memory'
-import { ContextAssembler } from './assembler'
-import { ContextFormatter } from './formatter'
-import { StandardsManager } from './standards-manager'
-import { ProgressTracker } from './progress-tracker'
-import { ContextCacheManager } from './cache-manager'
-import type { ContextOptions, AssembledContext } from './types'
-
-export * from './types'
-export * from './assembler'
-export * from './formatter'
-export * from './standards-manager'
-export * from './progress-tracker'
-export * from './cache-manager'
-export * from './hierarchy'
-export * from './validator'
-
-export class ContextManager {
-  readonly assembler: ContextAssembler
-  readonly formatter: typeof ContextFormatter
-  readonly standards: StandardsManager
-  readonly progress: ProgressTracker
-  readonly cache: ContextCacheManager
-
-  private logger: Logger
-
-  constructor(
-    logger: Logger,
-    vault: VaultManager,
-    memory: MemoryManager
-  ) {
-    this.logger = logger.child({ component: 'context-manager' })
-
-    this.assembler = new ContextAssembler(logger, vault, memory)
-    this.formatter = ContextFormatter
-    this.standards = new StandardsManager(logger, vault)
-    this.progress = new ProgressTracker(logger, vault)
-    this.cache = new ContextCacheManager(logger)
-  }
-
-  async getContext(
-    projectName: string,
-    options?: ContextOptions
-  ): Promise<AssembledContext> {
-    const cached = this.cache.get(projectName)
-    if (cached && !options?.maxTokens) {
-      return cached
-    }
-
-    const context = await this.assembler.assembleContext(projectName, options)
-
-    const dependencies = context.metadata.sources
-    this.cache.set(projectName, context, dependencies)
-
-    return context
-  }
-
-  async getFormattedContext(
-    projectName: string,
-    options?: ContextOptions
-  ): Promise<string> {
-    const context = await this.getContext(projectName, options)
-    return this.formatter.format(context)
-  }
-
-  invalidateContext(projectName: string): void {
-    this.cache.invalidate(projectName)
-    this.standards.clearCache()
-  }
-
-  getStats() {
-    return {
-      cache: this.cache.getStats()
-    }
-  }
-}
+/**
+ * Context Management System
+ * Main module that combines all context components
+ */
+
+import type { Logger } from 'pino'
+import type { VaultManager } from '@/vault'
+import type { MemoryManager } from '@/memory'
+import { ContextAssembler } from './assembler'
+import { ContextFormatter } from './formatter'
+import { StandardsManager } from './standards-manager'
+import { ProgressTracker } from './progress-tracker'
+import { ContextCacheManager } from './cache-manager'
+import type { ContextOptions, AssembledContext } from './types'
+
+export * from './types'
+export * from './assembler'
+export * from './formatter'
+export * from './standards-manager'
+export * from './progress-tracker'
+export * from './cache-manager'
+export * from './hierarchy'
+export * from './validator'
+
+export class ContextManager {
+  readonly assembler: ContextAssembler
+  readonly formatter: typeof ContextFormatter
+  readonly standards: StandardsManager
+  readonly progress: ProgressTracker
+  readonly cache: ContextCacheManager
+
+  private logger: Logger
+
+  constructor(
+    logger: Logger,
+    vault: VaultManager,
+    memory: MemoryManager
+  ) {
+    this.logger = logger.child({ component: 'context-manager' })
+
+    this.assembler = new ContextAssembler(logger, vault, memory)
+    this.formatter = ContextFormatter
+    this.standards = new StandardsManager(logger, vault)
+    this.progress = new ProgressTracker(logger, vault)
+    this.cache = new ContextCacheManager(logger)
+  }
+
+  async getContext(
+    projectName: string,
+    options?: ContextOptions
+  ): Promise<AssembledContext> {
+    const cached = this.cache.get(projectName)
+    if (cached && !options?.maxTokens) {
+      return cached
+    }
+
+    const context = await this.assembler.assembleContext(projectName, options)
+
+    const dependencies = context.metadata.sources
+    this.cache.set(projectName, context, dependencies)
+
+    return context
+  }
+
+  async getFormattedContext(
+    projectName: string,
+    options?: ContextOptions
+  ): Promise<string> {
+    const context = await this.getContext(projectName, options)
+    return this.formatter.format(context)
+  }
+
+  invalidateContext(projectName: string): void {
+    this.cache.invalidate(projectName)
+    this.standards.clearCache()
+  }
+
+  getStats() {
+    return {
+      cache: this.cache.getStats()
+    }
+  }
+}

package/src/context/progress-tracker.ts

@@ -1,174 +1,174 @@
-/**
- * Progress Tracker
- * Monitors and reports project development progress
- */
-
-import type { Logger } from 'pino'
-import type { VaultManager } from '@/vault'
-import type { ProgressState, TaskSummary, Blocker } from './types'
-
-export class ProgressTracker {
-  private logger: Logger
-  private vault: VaultManager
-
-  constructor(logger: Logger, vault: VaultManager) {
-    this.logger = logger.child({ component: 'progress-tracker' })
-    this.vault = vault
-  }
-
-  async getProgress(projectName: string): Promise<ProgressState> {
-    try {
-      const projectPaths = this.vault.getProjectPaths(projectName)
-      const file = await this.vault.reader.readMarkdownFile(projectPaths.progress)
-
-      return {
-        currentPhase: file.frontmatter.current_phase as string || 'unknown',
-        completionPercentage: (file.frontmatter.completion_percentage as number) || 0,
-        completedTasks: this.parseCompletedTasks(file.content),
-        currentTasks: this.parseCurrentTasks(file.content),
-        nextSteps: this.extractNextSteps(file.content),
-        blockers: this.parseBlockers(file.content),
-        velocity: this.calculateVelocity(file.content)
-      }
-
-    } catch (error) {
-      this.logger.error({ error, projectName }, 'Failed to get progress')
-      return this.createEmptyProgress()
-    }
-  }
-
-  async updateProgress(
-    projectName: string,
-    updates: Partial<ProgressState>
-  ): Promise<void> {
-    try {
-      const projectPaths = this.vault.getProjectPaths(projectName)
-
-      await this.vault.writer.updateFrontmatter(projectPaths.progress, {
-        current_phase: updates.currentPhase,
-        completion_percentage: updates.completionPercentage,
-        last_updated: new Date().toISOString().split('T')[0]
-      })
-
-      this.logger.info({ projectName }, 'Progress updated')
-
-    } catch (error) {
-      this.logger.error({ error, projectName }, 'Failed to update progress')
-      throw error
-    }
-  }
-
-  async addCompletedTask(
-    projectName: string,
-    task: TaskSummary
-  ): Promise<void> {
-    try {
-      const projectPaths = this.vault.getProjectPaths(projectName)
-
-      const entry = `\n- [x] ${task.title} (completed ${task.completedAt?.toLocaleDateString()})`
-
-      await this.vault.writer.appendContent(projectPaths.progress, entry, '\n')
-
-      this.logger.info({ projectName, task: task.title }, 'Task marked complete')
-
-    } catch (error) {
-      this.logger.error({ error, projectName }, 'Failed to add completed task')
-      throw error
-    }
-  }
-
-  private parseCompletedTasks(content: string): TaskSummary[] {
-    const tasks: TaskSummary[] = []
-    const completedRegex = /^[-*]\s+\[x\]\s+(.+?)(?:\(completed (.+?)\))?$/gim
-
-    let match
-    while ((match = completedRegex.exec(content)) !== null) {
-      tasks.push({
-        id: match[1].toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 50),
-        title: match[1].trim(),
-        status: 'done',
-        completedAt: match[2] ? new Date(match[2]) : undefined
-      })
-    }
-
-    return tasks
-  }
-
-  private parseCurrentTasks(content: string): TaskSummary[] {
-    const tasks: TaskSummary[] = []
-    const currentRegex = /^[-*]\s+\[([ >])\]\s+(.+?)$/gim
-
-    let match
-    while ((match = currentRegex.exec(content)) !== null) {
-      const status = match[1] === '>' ? 'in-progress' : 'todo'
-      tasks.push({
-        id: match[2].toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 50),
-        title: match[2].trim(),
-        status
-      })
-    }
-
-    return tasks
-  }
-
-  private extractNextSteps(content: string): string[] {
-    const section = /##\s+Next Steps\s+(.+?)(?=\n##|$)/is.exec(content)
-    if (!section) return []
-
-    const steps: string[] = []
-    const listRegex = /^[-*]\s+(.+)$/gm
-
-    let match
-    while ((match = listRegex.exec(section[1])) !== null) {
-      steps.push(match[1].trim())
-    }
-
-    return steps
-  }
-
-  private parseBlockers(content: string): Blocker[] {
-    const section = /##\s+Blockers\s+(.+?)(?=\n##|$)/is.exec(content)
-    if (!section) return []
-
-    const blockers: Blocker[] = []
-    const blockerRegex = /^[-*]\s+\[(\w+)\]\s+(.+?)(?:\(since (.+?)\))?$/gim
-
-    let match
-    while ((match = blockerRegex.exec(section[1])) !== null) {
-      blockers.push({
-        description: match[2].trim(),
-        severity: match[1].toLowerCase() as any,
-        since: match[3] ? new Date(match[3]) : new Date()
-      })
-    }
-
-    return blockers
-  }
-
-  private calculateVelocity(content: string): number {
-    const completedTasks = this.parseCompletedTasks(content)
-
-    if (completedTasks.length === 0) return 0
-
-    const oneWeekAgo = new Date()
-    oneWeekAgo.setDate(oneWeekAgo.getDate() - 7)
-
-    const recentTasks = completedTasks.filter(task =>
-      task.completedAt && task.completedAt >= oneWeekAgo
-    )
-
-    return recentTasks.length
-  }
-
-  private createEmptyProgress(): ProgressState {
-    return {
-      currentPhase: 'unknown',
-      completionPercentage: 0,
-      completedTasks: [],
-      currentTasks: [],
-      nextSteps: [],
-      blockers: [],
-      velocity: 0
-    }
-  }
-}
+/**
+ * Progress Tracker
+ * Monitors and reports project development progress
+ */
+
+import type { Logger } from 'pino'
+import type { VaultManager } from '@/vault'
+import type { ProgressState, TaskSummary, Blocker } from './types'
+
+export class ProgressTracker {
+  private logger: Logger
+  private vault: VaultManager
+
+  constructor(logger: Logger, vault: VaultManager) {
+    this.logger = logger.child({ component: 'progress-tracker' })
+    this.vault = vault
+  }
+
+  async getProgress(projectName: string): Promise<ProgressState> {
+    try {
+      const projectPaths = this.vault.getProjectPaths(projectName)
+      const file = await this.vault.reader.readMarkdownFile(projectPaths.progress)
+
+      return {
+        currentPhase: file.frontmatter.current_phase as string || 'unknown',
+        completionPercentage: (file.frontmatter.completion_percentage as number) || 0,
+        completedTasks: this.parseCompletedTasks(file.content),
+        currentTasks: this.parseCurrentTasks(file.content),
+        nextSteps: this.extractNextSteps(file.content),
+        blockers: this.parseBlockers(file.content),
+        velocity: this.calculateVelocity(file.content)
+      }
+
+    } catch (error) {
+      this.logger.error({ error, projectName }, 'Failed to get progress')
+      return this.createEmptyProgress()
+    }
+  }
+
+  async updateProgress(
+    projectName: string,
+    updates: Partial<ProgressState>
+  ): Promise<void> {
+    try {
+      const projectPaths = this.vault.getProjectPaths(projectName)
+
+      await this.vault.writer.updateFrontmatter(projectPaths.progress, {
+        current_phase: updates.currentPhase,
+        completion_percentage: updates.completionPercentage,
+        last_updated: new Date().toISOString().split('T')[0]
+      })
+
+      this.logger.info({ projectName }, 'Progress updated')
+
+    } catch (error) {
+      this.logger.error({ error, projectName }, 'Failed to update progress')
+      throw error
+    }
+  }
+
+  async addCompletedTask(
+    projectName: string,
+    task: TaskSummary
+  ): Promise<void> {
+    try {
+      const projectPaths = this.vault.getProjectPaths(projectName)
+
+      const entry = `\n- [x] ${task.title} (completed ${task.completedAt?.toLocaleDateString()})`
+
+      await this.vault.writer.appendContent(projectPaths.progress, entry, '\n')
+
+      this.logger.info({ projectName, task: task.title }, 'Task marked complete')
+
+    } catch (error) {
+      this.logger.error({ error, projectName }, 'Failed to add completed task')
+      throw error
+    }
+  }
+
+  private parseCompletedTasks(content: string): TaskSummary[] {
+    const tasks: TaskSummary[] = []
+    const completedRegex = /^[-*]\s+\[x\]\s+(.+?)(?:\(completed (.+?)\))?$/gim
+
+    let match
+    while ((match = completedRegex.exec(content)) !== null) {
+      tasks.push({
+        id: match[1].toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 50),
+        title: match[1].trim(),
+        status: 'done',
+        completedAt: match[2] ? new Date(match[2]) : undefined
+      })
+    }
+
+    return tasks
+  }
+
+  private parseCurrentTasks(content: string): TaskSummary[] {
+    const tasks: TaskSummary[] = []
+    const currentRegex = /^[-*]\s+\[([ >])\]\s+(.+?)$/gim
+
+    let match
+    while ((match = currentRegex.exec(content)) !== null) {
+      const status = match[1] === '>' ? 'in-progress' : 'todo'
+      tasks.push({
+        id: match[2].toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 50),
+        title: match[2].trim(),
+        status
+      })
+    }
+
+    return tasks
+  }
+
+  private extractNextSteps(content: string): string[] {
+    const section = /##\s+Next Steps\s+(.+?)(?=\n##|$)/is.exec(content)
+    if (!section) return []
+
+    const steps: string[] = []
+    const listRegex = /^[-*]\s+(.+)$/gm
+
+    let match
+    while ((match = listRegex.exec(section[1])) !== null) {
+      steps.push(match[1].trim())
+    }
+
+    return steps
+  }
+
+  private parseBlockers(content: string): Blocker[] {
+    const section = /##\s+Blockers\s+(.+?)(?=\n##|$)/is.exec(content)
+    if (!section) return []
+
+    const blockers: Blocker[] = []
+    const blockerRegex = /^[-*]\s+\[(\w+)\]\s+(.+?)(?:\(since (.+?)\))?$/gim
+
+    let match
+    while ((match = blockerRegex.exec(section[1])) !== null) {
+      blockers.push({
+        description: match[2].trim(),
+        severity: match[1].toLowerCase() as any,
+        since: match[3] ? new Date(match[3]) : new Date()
+      })
+    }
+
+    return blockers
+  }
+
+  private calculateVelocity(content: string): number {
+    const completedTasks = this.parseCompletedTasks(content)
+
+    if (completedTasks.length === 0) return 0
+
+    const oneWeekAgo = new Date()
+    oneWeekAgo.setDate(oneWeekAgo.getDate() - 7)
+
+    const recentTasks = completedTasks.filter(task =>
+      task.completedAt && task.completedAt >= oneWeekAgo
+    )
+
+    return recentTasks.length
+  }
+
+  private createEmptyProgress(): ProgressState {
+    return {
+      currentPhase: 'unknown',
+      completionPercentage: 0,
+      completedTasks: [],
+      currentTasks: [],
+      nextSteps: [],
+      blockers: [],
+      velocity: 0
+    }
+  }
+}