claude-brain 0.14.0 → 0.14.2

package/src/automation/auto-context.ts

@@ -1,240 +1,240 @@
-/**
- * Auto-Context Loader
- * Phase 12: Advanced Memory & Intelligent Automation
- *
- * Automatically detects project and loads context
- */
-
-import type { Logger } from 'pino'
-import type { ContextManager } from '@/context'
-import type { AssembledContext } from '@/context/types'
-import { ProjectDetector, type DetectedProject } from './project-detector'
-
-export interface LoadedContextEntry {
-  project: string
-  context: AssembledContext
-  loadedAt: Date
-  detected: DetectedProject
-}
-
-export interface AutoContextStats {
-  loadedContexts: number
-  directories: string[]
-  lastLoadTime?: Date
-}
-
-export class AutoContextLoader {
-  private logger: Logger
-  private context: ContextManager
-  private detector: ProjectDetector
-  private loadedContext: Map<string, LoadedContextEntry> = new Map()
-  private currentProject: string | null = null
-
-  constructor(
-    logger: Logger,
-    context: ContextManager,
-    detector: ProjectDetector
-  ) {
-    this.logger = logger.child({ component: 'auto-context-loader' })
-    this.context = context
-    this.detector = detector
-  }
-
-  /**
-   * Initialize and load context for current directory
-   */
-  async initialize(): Promise<DetectedProject | null> {
-    try {
-      const cwd = process.cwd()
-      const detected = await this.loadContextForDirectory(cwd)
-
-      this.logger.info(
-        { project: detected?.name },
-        'Auto-context loader initialized'
-      )
-
-      return detected
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to initialize auto-context loader')
-      return null
-    }
-  }
-
-  /**
-   * Load context for a directory
-   */
-  async loadContextForDirectory(directory: string): Promise<DetectedProject | null> {
-    // Check if already loaded
-    const existing = this.loadedContext.get(directory)
-    if (existing) {
-      this.logger.debug({ directory, project: existing.project }, 'Context already loaded')
-      this.currentProject = existing.project
-      return existing.detected
-    }
-
-    // Detect project
-    const detected = await this.detector.detectProject(directory)
-
-    if (!detected) {
-      this.logger.debug({ directory }, 'No project detected')
-      return null
-    }
-
-    if (detected.confidence < 0.5) {
-      this.logger.warn(
-        { project: detected.name, confidence: detected.confidence },
-        'Low confidence project detection - skipping auto-load'
-      )
-      return detected
-    }
-
-    // Load context
-    this.logger.info(
-      {
-        project: detected.name,
-        confidence: detected.confidence,
-        indicators: detected.indicators
-      },
-      'Auto-loading project context'
-    )
-
-    try {
-      const context = await this.context.getContext(detected.name)
-
-      this.loadedContext.set(directory, {
-        project: detected.name,
-        context,
-        loadedAt: new Date(),
-        detected
-      })
-
-      this.currentProject = detected.name
-
-      this.logger.info(
-        { project: detected.name },
-        'Context loaded successfully'
-      )
-
-      return detected
-
-    } catch (error) {
-      this.logger.error(
-        { error, project: detected.name },
-        'Failed to load context'
-      )
-      return detected
-    }
-  }
-
-  /**
-   * Get loaded context for directory
-   */
-  getLoadedContext(directory: string): LoadedContextEntry | undefined {
-    return this.loadedContext.get(directory)
-  }
-
-  /**
-   * Get current project context
-   */
-  getCurrentContext(): LoadedContextEntry | undefined {
-    const cwd = process.cwd()
-    return this.loadedContext.get(cwd)
-  }
-
-  /**
-   * Get current project name
-   */
-  getCurrentProject(): string | null {
-    return this.currentProject
-  }
-
-  /**
-   * Reload context for a directory
-   */
-  async reloadContext(directory: string): Promise<LoadedContextEntry | null> {
-    // Clear existing
-    this.loadedContext.delete(directory)
-
-    // Reload
-    const detected = await this.loadContextForDirectory(directory)
-
-    if (detected) {
-      return this.loadedContext.get(directory) || null
-    }
-
-    return null
-  }
-
-  /**
-   * Clear loaded context for a directory
-   */
-  clearContext(directory: string): void {
-    const entry = this.loadedContext.get(directory)
-    if (entry) {
-      this.logger.info({ project: entry.project }, 'Clearing context')
-      this.loadedContext.delete(directory)
-
-      if (this.currentProject === entry.project) {
-        this.currentProject = null
-      }
-    }
-  }
-
-  /**
-   * Clear all loaded contexts
-   */
-  clearAllContexts(): void {
-    this.loadedContext.clear()
-    this.currentProject = null
-    this.logger.info('All contexts cleared')
-  }
-
-  /**
-   * Get formatted context summary for current directory
-   */
-  async getContextSummary(): Promise<string | null> {
-    const current = this.getCurrentContext()
-
-    if (!current) {
-      return null
-    }
-
-    return this.context.getFormattedContext(current.project)
-  }
-
-  /**
-   * Check if context is loaded for directory
-   */
-  isContextLoaded(directory: string): boolean {
-    return this.loadedContext.has(directory)
-  }
-
-  /**
-   * Get auto-context statistics
-   */
-  getStats(): AutoContextStats {
-    const directories = Array.from(this.loadedContext.keys())
-    const lastEntry = Array.from(this.loadedContext.values())
-      .sort((a, b) => b.loadedAt.getTime() - a.loadedAt.getTime())[0]
-
-    return {
-      loadedContexts: this.loadedContext.size,
-      directories,
-      lastLoadTime: lastEntry?.loadedAt
-    }
-  }
-
-  /**
-   * Pre-load context for multiple directories
-   */
-  async preloadContexts(directories: string[]): Promise<Map<string, DetectedProject | null>> {
-    const results = new Map<string, DetectedProject | null>()
-
-    for (const dir of directories) {
-      const detected = await this.loadContextForDirectory(dir)
-      results.set(dir, detected)
-    }
-
-    return results
-  }
-}
+/**
+ * Auto-Context Loader
+ * Phase 12: Advanced Memory & Intelligent Automation
+ *
+ * Automatically detects project and loads context
+ */
+
+import type { Logger } from 'pino'
+import type { ContextManager } from '@/context'
+import type { AssembledContext } from '@/context/types'
+import { ProjectDetector, type DetectedProject } from './project-detector'
+
+export interface LoadedContextEntry {
+  project: string
+  context: AssembledContext
+  loadedAt: Date
+  detected: DetectedProject
+}
+
+export interface AutoContextStats {
+  loadedContexts: number
+  directories: string[]
+  lastLoadTime?: Date
+}
+
+export class AutoContextLoader {
+  private logger: Logger
+  private context: ContextManager
+  private detector: ProjectDetector
+  private loadedContext: Map<string, LoadedContextEntry> = new Map()
+  private currentProject: string | null = null
+
+  constructor(
+    logger: Logger,
+    context: ContextManager,
+    detector: ProjectDetector
+  ) {
+    this.logger = logger.child({ component: 'auto-context-loader' })
+    this.context = context
+    this.detector = detector
+  }
+
+  /**
+   * Initialize and load context for current directory
+   */
+  async initialize(): Promise<DetectedProject | null> {
+    try {
+      const cwd = process.cwd()
+      const detected = await this.loadContextForDirectory(cwd)
+
+      this.logger.info(
+        { project: detected?.name },
+        'Auto-context loader initialized'
+      )
+
+      return detected
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to initialize auto-context loader')
+      return null
+    }
+  }
+
+  /**
+   * Load context for a directory
+   */
+  async loadContextForDirectory(directory: string): Promise<DetectedProject | null> {
+    // Check if already loaded
+    const existing = this.loadedContext.get(directory)
+    if (existing) {
+      this.logger.debug({ directory, project: existing.project }, 'Context already loaded')
+      this.currentProject = existing.project
+      return existing.detected
+    }
+
+    // Detect project
+    const detected = await this.detector.detectProject(directory)
+
+    if (!detected) {
+      this.logger.debug({ directory }, 'No project detected')
+      return null
+    }
+
+    if (detected.confidence < 0.5) {
+      this.logger.warn(
+        { project: detected.name, confidence: detected.confidence },
+        'Low confidence project detection - skipping auto-load'
+      )
+      return detected
+    }
+
+    // Load context
+    this.logger.info(
+      {
+        project: detected.name,
+        confidence: detected.confidence,
+        indicators: detected.indicators
+      },
+      'Auto-loading project context'
+    )
+
+    try {
+      const context = await this.context.getContext(detected.name)
+
+      this.loadedContext.set(directory, {
+        project: detected.name,
+        context,
+        loadedAt: new Date(),
+        detected
+      })
+
+      this.currentProject = detected.name
+
+      this.logger.info(
+        { project: detected.name },
+        'Context loaded successfully'
+      )
+
+      return detected
+
+    } catch (error) {
+      this.logger.error(
+        { error, project: detected.name },
+        'Failed to load context'
+      )
+      return detected
+    }
+  }
+
+  /**
+   * Get loaded context for directory
+   */
+  getLoadedContext(directory: string): LoadedContextEntry | undefined {
+    return this.loadedContext.get(directory)
+  }
+
+  /**
+   * Get current project context
+   */
+  getCurrentContext(): LoadedContextEntry | undefined {
+    const cwd = process.cwd()
+    return this.loadedContext.get(cwd)
+  }
+
+  /**
+   * Get current project name
+   */
+  getCurrentProject(): string | null {
+    return this.currentProject
+  }
+
+  /**
+   * Reload context for a directory
+   */
+  async reloadContext(directory: string): Promise<LoadedContextEntry | null> {
+    // Clear existing
+    this.loadedContext.delete(directory)
+
+    // Reload
+    const detected = await this.loadContextForDirectory(directory)
+
+    if (detected) {
+      return this.loadedContext.get(directory) || null
+    }
+
+    return null
+  }
+
+  /**
+   * Clear loaded context for a directory
+   */
+  clearContext(directory: string): void {
+    const entry = this.loadedContext.get(directory)
+    if (entry) {
+      this.logger.info({ project: entry.project }, 'Clearing context')
+      this.loadedContext.delete(directory)
+
+      if (this.currentProject === entry.project) {
+        this.currentProject = null
+      }
+    }
+  }
+
+  /**
+   * Clear all loaded contexts
+   */
+  clearAllContexts(): void {
+    this.loadedContext.clear()
+    this.currentProject = null
+    this.logger.info('All contexts cleared')
+  }
+
+  /**
+   * Get formatted context summary for current directory
+   */
+  async getContextSummary(): Promise<string | null> {
+    const current = this.getCurrentContext()
+
+    if (!current) {
+      return null
+    }
+
+    return this.context.getFormattedContext(current.project)
+  }
+
+  /**
+   * Check if context is loaded for directory
+   */
+  isContextLoaded(directory: string): boolean {
+    return this.loadedContext.has(directory)
+  }
+
+  /**
+   * Get auto-context statistics
+   */
+  getStats(): AutoContextStats {
+    const directories = Array.from(this.loadedContext.keys())
+    const lastEntry = Array.from(this.loadedContext.values())
+      .sort((a, b) => b.loadedAt.getTime() - a.loadedAt.getTime())[0]
+
+    return {
+      loadedContexts: this.loadedContext.size,
+      directories,
+      lastLoadTime: lastEntry?.loadedAt
+    }
+  }
+
+  /**
+   * Pre-load context for multiple directories
+   */
+  async preloadContexts(directories: string[]): Promise<Map<string, DetectedProject | null>> {
+    const results = new Map<string, DetectedProject | null>()
+
+    for (const dir of directories) {
+      const detected = await this.loadContextForDirectory(dir)
+      results.set(dir, detected)
+    }
+
+    return results
+  }
+}