claude-brain 0.14.2 → 0.14.4

package/src/orchestrator/handlers/status-handler.ts

@@ -1,131 +1,131 @@
-/**
- * StatusChangeHandler - Detects status changes in project files
- */
-
-import type { Logger } from 'pino'
-import type { Event, EventType, EventPriority } from '../types'
-import type { VaultReader } from '@/vault'
-import { BaseHandler } from './base-handler'
-import type { EventBus } from '../event-emitter'
-
-export interface StatusChange {
-  filePath: string
-  previousStatus: string
-  currentStatus: string
-  project?: string
-}
-
-export class StatusChangeHandler extends BaseHandler {
-  name = 'status-change-handler'
-  types: EventType[] = ['file:modified']
-  priority: EventPriority = 'normal'
-
-  private vaultReader: VaultReader
-  private previousStatuses: Map<string, string>
-  private eventBus: EventBus | null = null
-
-  constructor(logger: Logger, vaultReader: VaultReader) {
-    super(logger)
-    this.initLogger(logger)
-    this.vaultReader = vaultReader
-    this.previousStatuses = new Map()
-  }
-
-  /**
-   * Set the event bus for emitting status change events
-   */
-  setEventBus(eventBus: EventBus): void {
-    this.eventBus = eventBus
-  }
-
-  async handle(event: Event): Promise<void> {
-    this.logHandling(event)
-
-    const filePath = event.payload.path as string
-
-    try {
-      // Read file and check for status changes
-      const file = await this.vaultReader.readMarkdownFile(filePath, false)
-      const currentStatus = file.frontmatter.status as string | undefined
-
-      if (!currentStatus) {
-        return
-      }
-
-      const previousStatus = this.previousStatuses.get(filePath)
-
-      if (previousStatus && previousStatus !== currentStatus) {
-        const statusChange: StatusChange = {
-          filePath,
-          previousStatus,
-          currentStatus,
-          project: file.frontmatter.project as string | undefined
-        }
-
-        this.logger.info(
-          { filePath, from: previousStatus, to: currentStatus },
-          'Status changed'
-        )
-
-        // Emit status change event if event bus is available
-        if (this.eventBus) {
-          this.eventBus.emitEvent(
-            'project:updated',
-            {
-              statusChange,
-              filePath,
-              project: file.frontmatter.project
-            },
-            this.name
-          )
-        }
-
-        this.logSuccess(event, { from: previousStatus, to: currentStatus })
-      }
-
-      // Update cached status
-      this.previousStatuses.set(filePath, currentStatus)
-    } catch (error) {
-      this.logError(event, error)
-    }
-  }
-
-  /**
-   * Initialize status tracking for a file
-   */
-  async initializeStatus(filePath: string): Promise<void> {
-    try {
-      const file = await this.vaultReader.readMarkdownFile(filePath, false)
-      const status = file.frontmatter.status as string | undefined
-
-      if (status) {
-        this.previousStatuses.set(filePath, status)
-        this.logger.debug({ filePath, status }, 'Status initialized')
-      }
-    } catch (error) {
-      this.logger.warn({ filePath, error }, 'Failed to initialize status')
-    }
-  }
-
-  /**
-   * Get cached status for a file
-   */
-  getCachedStatus(filePath: string): string | undefined {
-    return this.previousStatuses.get(filePath)
-  }
-
-  /**
-   * Clear status cache
-   */
-  clearStatusCache(): void {
-    this.previousStatuses.clear()
-    this.logger.debug('Status cache cleared')
-  }
-
-  /**
-   * Get all tracked file paths
-   */
-  getTrackedFiles(): string[] {
-    return Array.from(this.previousStatuses.keys())
-  }
-}
+/**
+ * StatusChangeHandler - Detects status changes in project files
+ */
+
+import type { Logger } from 'pino'
+import type { Event, EventType, EventPriority } from '../types'
+import type { VaultReader } from '@/vault'
+import { BaseHandler } from './base-handler'
+import type { EventBus } from '../event-emitter'
+
+export interface StatusChange {
+  filePath: string
+  previousStatus: string
+  currentStatus: string
+  project?: string
+}
+
+export class StatusChangeHandler extends BaseHandler {
+  name = 'status-change-handler'
+  types: EventType[] = ['file:modified']
+  priority: EventPriority = 'normal'
+
+  private vaultReader: VaultReader
+  private previousStatuses: Map<string, string>
+  private eventBus: EventBus | null = null
+
+  constructor(logger: Logger, vaultReader: VaultReader) {
+    super(logger)
+    this.initLogger(logger)
+    this.vaultReader = vaultReader
+    this.previousStatuses = new Map()
+  }
+
+  /**
+   * Set the event bus for emitting status change events
+   */
+  setEventBus(eventBus: EventBus): void {
+    this.eventBus = eventBus
+  }
+
+  async handle(event: Event): Promise<void> {
+    this.logHandling(event)
+
+    const filePath = event.payload.path as string
+
+    try {
+      // Read file and check for status changes
+      const file = await this.vaultReader.readMarkdownFile(filePath, false)
+      const currentStatus = file.frontmatter.status as string | undefined
+
+      if (!currentStatus) {
+        return
+      }
+
+      const previousStatus = this.previousStatuses.get(filePath)
+
+      if (previousStatus && previousStatus !== currentStatus) {
+        const statusChange: StatusChange = {
+          filePath,
+          previousStatus,
+          currentStatus,
+          project: file.frontmatter.project as string | undefined
+        }
+
+        this.logger.info(
+          { filePath, from: previousStatus, to: currentStatus },
+          'Status changed'
+        )
+
+        // Emit status change event if event bus is available
+        if (this.eventBus) {
+          this.eventBus.emitEvent(
+            'project:updated',
+            {
+              statusChange,
+              filePath,
+              project: file.frontmatter.project
+            },
+            this.name
+          )
+        }
+
+        this.logSuccess(event, { from: previousStatus, to: currentStatus })
+      }
+
+      // Update cached status
+      this.previousStatuses.set(filePath, currentStatus)
+    } catch (error) {
+      this.logError(event, error)
+    }
+  }
+
+  /**
+   * Initialize status tracking for a file
+   */
+  async initializeStatus(filePath: string): Promise<void> {
+    try {
+      const file = await this.vaultReader.readMarkdownFile(filePath, false)
+      const status = file.frontmatter.status as string | undefined
+
+      if (status) {
+        this.previousStatuses.set(filePath, status)
+        this.logger.debug({ filePath, status }, 'Status initialized')
+      }
+    } catch (error) {
+      this.logger.warn({ filePath, error }, 'Failed to initialize status')
+    }
+  }
+
+  /**
+   * Get cached status for a file
+   */
+  getCachedStatus(filePath: string): string | undefined {
+    return this.previousStatuses.get(filePath)
+  }
+
+  /**
+   * Clear status cache
+   */
+  clearStatusCache(): void {
+    this.previousStatuses.clear()
+    this.logger.debug('Status cache cleared')
+  }
+
+  /**
+   * Get all tracked file paths
+   */
+  getTrackedFiles(): string[] {
+    return Array.from(this.previousStatuses.keys())
+  }
+}

package/src/orchestrator/handlers/task-handler.ts

@@ -1,171 +1,171 @@
-/**
- * TaskHandler - Detects and processes tasks from progress.md files
- */
-
-import type { Logger } from 'pino'
-import type { Event, EventType, EventPriority } from '../types'
-import type { VaultReader } from '@/vault'
-import { BaseHandler } from './base-handler'
-import type { EventBus } from '../event-emitter'
-
-export interface DetectedTask {
-  title: string
-  status: string
-  description?: string
-}
-
-export class TaskHandler extends BaseHandler {
-  name = 'task-handler'
-  types: EventType[] = ['file:created', 'file:modified']
-  priority: EventPriority = 'normal'
-
-  private vaultReader: VaultReader
-  private eventBus: EventBus | null = null
-
-  constructor(logger: Logger, vaultReader: VaultReader) {
-    super(logger)
-    this.initLogger(logger)
-    this.vaultReader = vaultReader
-  }
-
-  /**
-   * Set the event bus for emitting task events
-   */
-  setEventBus(eventBus: EventBus): void {
-    this.eventBus = eventBus
-  }
-
-  async handle(event: Event): Promise<void> {
-    this.logHandling(event)
-
-    const filePath = event.payload.path as string
-
-    // Only process progress.md files
-    if (!this.shouldHandleFile(filePath, ['progress.md'])) {
-      return
-    }
-
-    try {
-      // Read file
-      const file = await this.vaultReader.readMarkdownFile(filePath, false)
-
-      // Check for task markers in content
-      const tasks = this.extractTasks(file.content)
-
-      if (tasks.length > 0) {
-        this.logger.info(
-          { filePath, taskCount: tasks.length },
-          'Tasks detected'
-        )
-
-        // Emit task events if event bus is available
-        if (this.eventBus) {
-          for (const task of tasks) {
-            const eventType = this.getTaskEventType(task.status)
-            this.eventBus.emitEvent(
-              eventType,
-              {
-                task,
-                filePath,
-                project: file.frontmatter.project
-              },
-              this.name
-            )
-          }
-        }
-
-        this.logSuccess(event, { taskCount: tasks.length })
-      }
-    } catch (error) {
-      this.logError(event, error)
-    }
-  }
-
-  /**
-   * Extract tasks from markdown content
-   */
-  private extractTasks(content: string): DetectedTask[] {
-    const tasks: DetectedTask[] = []
-
-    // Look for task patterns like:
-    // ## Task: [title]
-    // Status: [status]
-    const taskRegex = /##\s+Task:\s+(.+?)(?:\n|$)/gi
-    const statusRegex = /Status:\s+(.+?)(?:\n|$)/i
-
-    let match
-    while ((match = taskRegex.exec(content)) !== null) {
-      const title = match[1]?.trim() ?? ''
-      if (!title) continue
-
-      const sectionStart = match.index
-      const nextSection = content.indexOf('##', sectionStart + 1)
-      const sectionEnd = nextSection === -1 ? content.length : nextSection
-      const section = content.slice(sectionStart, sectionEnd)
-
-      const statusMatch = statusRegex.exec(section)
-      const status = statusMatch?.[1]?.trim() ?? 'unknown'
-
-      tasks.push({
-        title,
-        status,
-        description: section.slice(match[0].length, 100).trim()
-      })
-    }
-
-    // Also look for checkbox-style tasks
-    const checkboxTasks = this.extractCheckboxTasks(content)
-    tasks.push(...checkboxTasks)
-
-    return tasks
-  }
-
-  /**
-   * Extract checkbox-style tasks
-   */
-  private extractCheckboxTasks(content: string): DetectedTask[] {
-    const tasks: DetectedTask[] = []
-
-    // Match: - [ ] Task, - [x] Task, - [>] Task, - [!] Task
-    const checkboxRegex = /^[-*]\s+\[([ xX>!])\]\s+(.+)$/gm
-
-    let match
-    while ((match = checkboxRegex.exec(content)) !== null) {
-      const statusChar = match[1] ?? ' '
-      const title = match[2]?.trim() ?? ''
-      if (!title) continue
-
-      let status: string
-      if (statusChar === 'x' || statusChar === 'X') {
-        status = 'done'
-      } else if (statusChar === '>') {
-        status = 'in-progress'
-      } else if (statusChar === '!') {
-        status = 'blocked'
-      } else {
-        status = 'todo'
-      }
-
-      tasks.push({ title, status })
-    }
-
-    return tasks
-  }
-
-  /**
-   * Map task status to event type
-   */
-  private getTaskEventType(status: string): EventType {
-    const normalizedStatus = status.toLowerCase()
-
-    if (normalizedStatus.includes('done') || normalizedStatus.includes('complete')) {
-      return 'task:completed'
-    } else if (normalizedStatus.includes('block')) {
-      return 'task:blocked'
-    } else if (normalizedStatus.includes('progress') || normalizedStatus.includes('doing')) {
-      return 'task:updated'
-    } else {
-      return 'task:created'
-    }
-  }
-}
+/**
+ * TaskHandler - Detects and processes tasks from progress.md files
+ */
+
+import type { Logger } from 'pino'
+import type { Event, EventType, EventPriority } from '../types'
+import type { VaultReader } from '@/vault'
+import { BaseHandler } from './base-handler'
+import type { EventBus } from '../event-emitter'
+
+export interface DetectedTask {
+  title: string
+  status: string
+  description?: string
+}
+
+export class TaskHandler extends BaseHandler {
+  name = 'task-handler'
+  types: EventType[] = ['file:created', 'file:modified']
+  priority: EventPriority = 'normal'
+
+  private vaultReader: VaultReader
+  private eventBus: EventBus | null = null
+
+  constructor(logger: Logger, vaultReader: VaultReader) {
+    super(logger)
+    this.initLogger(logger)
+    this.vaultReader = vaultReader
+  }
+
+  /**
+   * Set the event bus for emitting task events
+   */
+  setEventBus(eventBus: EventBus): void {
+    this.eventBus = eventBus
+  }
+
+  async handle(event: Event): Promise<void> {
+    this.logHandling(event)
+
+    const filePath = event.payload.path as string
+
+    // Only process progress.md files
+    if (!this.shouldHandleFile(filePath, ['progress.md'])) {
+      return
+    }
+
+    try {
+      // Read file
+      const file = await this.vaultReader.readMarkdownFile(filePath, false)
+
+      // Check for task markers in content
+      const tasks = this.extractTasks(file.content)
+
+      if (tasks.length > 0) {
+        this.logger.info(
+          { filePath, taskCount: tasks.length },
+          'Tasks detected'
+        )
+
+        // Emit task events if event bus is available
+        if (this.eventBus) {
+          for (const task of tasks) {
+            const eventType = this.getTaskEventType(task.status)
+            this.eventBus.emitEvent(
+              eventType,
+              {
+                task,
+                filePath,
+                project: file.frontmatter.project
+              },
+              this.name
+            )
+          }
+        }
+
+        this.logSuccess(event, { taskCount: tasks.length })
+      }
+    } catch (error) {
+      this.logError(event, error)
+    }
+  }
+
+  /**
+   * Extract tasks from markdown content
+   */
+  private extractTasks(content: string): DetectedTask[] {
+    const tasks: DetectedTask[] = []
+
+    // Look for task patterns like:
+    // ## Task: [title]
+    // Status: [status]
+    const taskRegex = /##\s+Task:\s+(.+?)(?:\n|$)/gi
+    const statusRegex = /Status:\s+(.+?)(?:\n|$)/i
+
+    let match
+    while ((match = taskRegex.exec(content)) !== null) {
+      const title = match[1]?.trim() ?? ''
+      if (!title) continue
+
+      const sectionStart = match.index
+      const nextSection = content.indexOf('##', sectionStart + 1)
+      const sectionEnd = nextSection === -1 ? content.length : nextSection
+      const section = content.slice(sectionStart, sectionEnd)
+
+      const statusMatch = statusRegex.exec(section)
+      const status = statusMatch?.[1]?.trim() ?? 'unknown'
+
+      tasks.push({
+        title,
+        status,
+        description: section.slice(match[0].length, 100).trim()
+      })
+    }
+
+    // Also look for checkbox-style tasks
+    const checkboxTasks = this.extractCheckboxTasks(content)
+    tasks.push(...checkboxTasks)
+
+    return tasks
+  }
+
+  /**
+   * Extract checkbox-style tasks
+   */
+  private extractCheckboxTasks(content: string): DetectedTask[] {
+    const tasks: DetectedTask[] = []
+
+    // Match: - [ ] Task, - [x] Task, - [>] Task, - [!] Task
+    const checkboxRegex = /^[-*]\s+\[([ xX>!])\]\s+(.+)$/gm
+
+    let match
+    while ((match = checkboxRegex.exec(content)) !== null) {
+      const statusChar = match[1] ?? ' '
+      const title = match[2]?.trim() ?? ''
+      if (!title) continue
+
+      let status: string
+      if (statusChar === 'x' || statusChar === 'X') {
+        status = 'done'
+      } else if (statusChar === '>') {
+        status = 'in-progress'
+      } else if (statusChar === '!') {
+        status = 'blocked'
+      } else {
+        status = 'todo'
+      }
+
+      tasks.push({ title, status })
+    }
+
+    return tasks
+  }
+
+  /**
+   * Map task status to event type
+   */
+  private getTaskEventType(status: string): EventType {
+    const normalizedStatus = status.toLowerCase()
+
+    if (normalizedStatus.includes('done') || normalizedStatus.includes('complete')) {
+      return 'task:completed'
+    } else if (normalizedStatus.includes('block')) {
+      return 'task:blocked'
+    } else if (normalizedStatus.includes('progress') || normalizedStatus.includes('doing')) {
+      return 'task:updated'
+    } else {
+      return 'task:created'
+    }
+  }
+}