claude-brain 0.14.2 → 0.14.4

package/src/vault/index.ts

@@ -1,318 +1,318 @@
-/**
- * Vault Integration Module
- * Barrel exports and VaultManager convenience class
- */
-
-import fs from 'fs/promises'
-import type { Logger } from 'pino'
-import type { VaultPaths, VaultConfig, MarkdownFile, Frontmatter } from './types'
-import { VaultPathUtils } from './paths'
-import { VaultReader } from './reader'
-import { VaultWriter } from './writer'
-import { VaultWatcher, type FileChangeEvent } from './watcher'
-import { VaultQuery, type QueryOptions, type QueryResult } from './query'
-import { FrontmatterUtils } from './frontmatter'
-
-// Re-export all types
-export * from './types'
-export * from './paths'
-export * from './templates'
-export * from './reader'
-export * from './writer'
-export * from './watcher'
-export * from './query'
-export * from './frontmatter'
-
-/**
- * VaultManager combines all vault functionality into a single interface
- */
-export class VaultManager {
-  readonly reader: VaultReader
-  readonly writer: VaultWriter
-  readonly watcher: VaultWatcher
-  readonly query: VaultQuery
-  readonly paths: VaultPaths
-  private logger: Logger
-  private config: VaultConfig
-
-  constructor(
-    vaultRoot: string,
-    logger: Logger,
-    config: Partial<VaultConfig> = {}
-  ) {
-    this.config = {
-      root: vaultRoot,
-      backupDir: config.backupDir ?? './data/backups',
-      cacheEnabled: config.cacheEnabled ?? true,
-      watchEnabled: config.watchEnabled ?? true,
-      debounceMs: config.debounceMs ?? 500
-    }
-
-    this.logger = logger.child({ component: 'vault-manager' })
-    this.paths = VaultPathUtils.getVaultPaths(vaultRoot)
-    this.reader = new VaultReader(logger, {
-      maxCacheSize: 100,
-      cacheMaxAge: 5 * 60 * 1000
-    })
-    this.writer = new VaultWriter(logger, this.config.backupDir)
-    this.watcher = new VaultWatcher(logger, this.config.debounceMs)
-    this.query = new VaultQuery(this.reader, logger)
-
-    // Wire up watcher to invalidate cache on file changes
-    this.watcher.on('change', (event: FileChangeEvent) => {
-      this.reader.invalidateCache(event.path)
-      this.logger.debug({ event }, 'Cache invalidated due to file change')
-    })
-  }
-
-  /**
-   * Initialize vault (create directories if needed)
-   */
-  async initialize(): Promise<void> {
-    const dirs = [
-      this.paths.projects,
-      this.paths.global,
-      this.paths.templates,
-      this.paths.memory
-    ]
-
-    for (const dir of dirs) {
-      await fs.mkdir(dir, { recursive: true })
-    }
-
-    this.logger.info({ paths: this.paths }, 'Vault initialized')
-  }
-
-  /**
-   * Start watching vault for changes
-   */
-  startWatching(): void {
-    if (!this.config.watchEnabled) {
-      this.logger.warn('File watching is disabled')
-      return
-    }
-
-    // Refresh file states before watching
-    this.watcher.refreshFileStates(this.paths.projects)
-    this.watcher.watch(this.paths.projects, true)
-    this.watcher.watch(this.paths.global, true)
-
-    this.logger.info('Started watching vault')
-  }
-
-  /**
-   * Stop watching vault
-   */
-  stopWatching(): void {
-    this.watcher.unwatchAll()
-    this.logger.info('Stopped watching vault')
-  }
-
-  /**
-   * Get project paths for a specific project
-   */
-  getProjectPaths(projectName: string) {
-    return VaultPathUtils.getProjectPaths(this.config.root, projectName)
-  }
-
-  /**
-   * Create a new project
-   */
-  async createProject(projectName: string): Promise<void> {
-    const normalizedName = VaultPathUtils.normalizeProjectName(projectName)
-
-    if (!VaultPathUtils.isValidProjectName(normalizedName)) {
-      throw new Error(`Invalid project name: ${projectName}`)
-    }
-
-    const projectPaths = this.getProjectPaths(normalizedName)
-
-    // Check if project already exists
-    if (await this.reader.fileExists(projectPaths.context)) {
-      throw new Error(`Project already exists: ${normalizedName}`)
-    }
-
-    await this.writer.createProjectStructure(projectPaths.root, normalizedName)
-    this.logger.info({ projectName: normalizedName }, 'Project created')
-  }
-
-  /**
-   * Get project context
-   */
-  async getProjectContext(projectName: string): Promise<MarkdownFile | null> {
-    const projectPaths = this.getProjectPaths(projectName)
-
-    try {
-      return await this.reader.readMarkdownFile(projectPaths.context)
-    } catch {
-      return null
-    }
-  }
-
-  /**
-   * Update project progress
-   */
-  async updateProgress(
-    projectName: string,
-    updates: {
-      status?: string
-      currentPhase?: string
-      completionPercentage?: number
-      content?: string
-    }
-  ): Promise<void> {
-    const projectPaths = this.getProjectPaths(projectName)
-
-    const frontmatterUpdates: Partial<Frontmatter> = {}
-    if (updates.status) frontmatterUpdates.status = updates.status
-    if (updates.currentPhase) frontmatterUpdates.current_phase = updates.currentPhase
-    if (updates.completionPercentage !== undefined) {
-      frontmatterUpdates.completion_percentage = updates.completionPercentage
-    }
-
-    await this.writer.updateFrontmatter(projectPaths.progress, frontmatterUpdates)
-
-    if (updates.content) {
-      await this.writer.appendContent(projectPaths.progress, updates.content)
-    }
-
-    this.logger.info({ projectName, updates }, 'Progress updated')
-  }
-
-  /**
-   * Add a decision to the decision log
-   */
-  async addDecision(
-    projectName: string,
-    decision: {
-      title: string
-      context: string
-      decision: string
-      consequences: string
-      status?: string
-    }
-  ): Promise<void> {
-    const projectPaths = this.getProjectPaths(projectName)
-
-    // Read current decisions to get count
-    const decisionsFile = await this.reader.readMarkdownFile(projectPaths.decisions)
-    const currentCount = FrontmatterUtils.getDecisionCount(decisionsFile.frontmatter)
-    const newCount = currentCount + 1
-
-    // Format the decision entry
-    const today = new Date().toISOString().split('T')[0]
-    const decisionEntry = `
-## Decision ${newCount}: ${decision.title}
-
-**Date:** ${today}
-**Status:** ${decision.status || 'accepted'}
-**Context:** ${decision.context}
-
-### Decision
-${decision.decision}
-
-### Consequences
-${decision.consequences}
-
----`
-
-    // Update frontmatter with new count
-    await this.writer.updateFrontmatter(projectPaths.decisions, {
-      decision_count: newCount,
-      last_updated: today
-    })
-
-    // Append the decision
-    await this.writer.appendContent(projectPaths.decisions, decisionEntry)
-
-    this.logger.info(
-      { projectName, decisionNumber: newCount, title: decision.title },
-      'Decision added'
-    )
-  }
-
-  /**
-   * Search across the vault
-   */
-  async search(options: QueryOptions): Promise<QueryResult[]> {
-    const { results } = await this.query.query(this.config.root, options)
-    return results
-  }
-
-  /**
-   * Get all projects
-   */
-  async listProjects(): Promise<string[]> {
-    return this.reader.getProjectDirectories(this.paths.projects)
-  }
-
-  /**
-   * Get project metadata
-   */
-  async getProjectMetadata(projectName: string): Promise<{
-    name: string
-    status: string
-    techStack: string[]
-    tags: string[]
-    currentPhase: string
-    completionPercentage: number
-  } | null> {
-    const context = await this.getProjectContext(projectName)
-    if (!context) return null
-
-    const projectPaths = this.getProjectPaths(projectName)
-    let progress: MarkdownFile | null = null
-
-    try {
-      progress = await this.reader.readMarkdownFile(projectPaths.progress)
-    } catch {
-      // Progress file might not exist
-    }
-
-    return {
-      name: projectName,
-      status: FrontmatterUtils.getStatus(context.frontmatter) || 'unknown',
-      techStack: FrontmatterUtils.getTechStack(context.frontmatter),
-      tags: FrontmatterUtils.getTags(context.frontmatter),
-      currentPhase: progress
-        ? FrontmatterUtils.getCurrentPhase(progress.frontmatter) || 'unknown'
-        : 'unknown',
-      completionPercentage: progress
-        ? FrontmatterUtils.getCompletionPercentage(progress.frontmatter)
-        : 0
-    }
-  }
-
-  /**
-   * Cleanup resources
-   */
-  async cleanup(): Promise<void> {
-    this.stopWatching()
-    this.reader.clearCache()
-
-    // Clean old backups
-    await this.writer.cleanOldBackups()
-
-    this.logger.info('Vault manager cleaned up')
-  }
-
-  /**
-   * Get vault statistics
-   */
-  async getStats(): Promise<{
-    projectCount: number
-    totalFiles: number
-    cacheStats: { size: number; files: string[] }
-    watcherStatus: { watching: string[]; activeDebounces: number }
-  }> {
-    const projects = await this.listProjects()
-    const allFiles = await this.reader.readDirectory(this.paths.projects, true)
-
-    return {
-      projectCount: projects.length,
-      totalFiles: allFiles.length,
-      cacheStats: this.reader.getCacheStats(),
-      watcherStatus: this.watcher.getStatus()
-    }
-  }
-}
+/**
+ * Vault Integration Module
+ * Barrel exports and VaultManager convenience class
+ */
+
+import fs from 'fs/promises'
+import type { Logger } from 'pino'
+import type { VaultPaths, VaultConfig, MarkdownFile, Frontmatter } from './types'
+import { VaultPathUtils } from './paths'
+import { VaultReader } from './reader'
+import { VaultWriter } from './writer'
+import { VaultWatcher, type FileChangeEvent } from './watcher'
+import { VaultQuery, type QueryOptions, type QueryResult } from './query'
+import { FrontmatterUtils } from './frontmatter'
+
+// Re-export all types
+export * from './types'
+export * from './paths'
+export * from './templates'
+export * from './reader'
+export * from './writer'
+export * from './watcher'
+export * from './query'
+export * from './frontmatter'
+
+/**
+ * VaultManager combines all vault functionality into a single interface
+ */
+export class VaultManager {
+  readonly reader: VaultReader
+  readonly writer: VaultWriter
+  readonly watcher: VaultWatcher
+  readonly query: VaultQuery
+  readonly paths: VaultPaths
+  private logger: Logger
+  private config: VaultConfig
+
+  constructor(
+    vaultRoot: string,
+    logger: Logger,
+    config: Partial<VaultConfig> = {}
+  ) {
+    this.config = {
+      root: vaultRoot,
+      backupDir: config.backupDir ?? './data/backups',
+      cacheEnabled: config.cacheEnabled ?? true,
+      watchEnabled: config.watchEnabled ?? true,
+      debounceMs: config.debounceMs ?? 500
+    }
+
+    this.logger = logger.child({ component: 'vault-manager' })
+    this.paths = VaultPathUtils.getVaultPaths(vaultRoot)
+    this.reader = new VaultReader(logger, {
+      maxCacheSize: 100,
+      cacheMaxAge: 5 * 60 * 1000
+    })
+    this.writer = new VaultWriter(logger, this.config.backupDir)
+    this.watcher = new VaultWatcher(logger, this.config.debounceMs)
+    this.query = new VaultQuery(this.reader, logger)
+
+    // Wire up watcher to invalidate cache on file changes
+    this.watcher.on('change', (event: FileChangeEvent) => {
+      this.reader.invalidateCache(event.path)
+      this.logger.debug({ event }, 'Cache invalidated due to file change')
+    })
+  }
+
+  /**
+   * Initialize vault (create directories if needed)
+   */
+  async initialize(): Promise<void> {
+    const dirs = [
+      this.paths.projects,
+      this.paths.global,
+      this.paths.templates,
+      this.paths.memory
+    ]
+
+    for (const dir of dirs) {
+      await fs.mkdir(dir, { recursive: true })
+    }
+
+    this.logger.info({ paths: this.paths }, 'Vault initialized')
+  }
+
+  /**
+   * Start watching vault for changes
+   */
+  startWatching(): void {
+    if (!this.config.watchEnabled) {
+      this.logger.warn('File watching is disabled')
+      return
+    }
+
+    // Refresh file states before watching
+    this.watcher.refreshFileStates(this.paths.projects)
+    this.watcher.watch(this.paths.projects, true)
+    this.watcher.watch(this.paths.global, true)
+
+    this.logger.info('Started watching vault')
+  }
+
+  /**
+   * Stop watching vault
+   */
+  stopWatching(): void {
+    this.watcher.unwatchAll()
+    this.logger.info('Stopped watching vault')
+  }
+
+  /**
+   * Get project paths for a specific project
+   */
+  getProjectPaths(projectName: string) {
+    return VaultPathUtils.getProjectPaths(this.config.root, projectName)
+  }
+
+  /**
+   * Create a new project
+   */
+  async createProject(projectName: string): Promise<void> {
+    const normalizedName = VaultPathUtils.normalizeProjectName(projectName)
+
+    if (!VaultPathUtils.isValidProjectName(normalizedName)) {
+      throw new Error(`Invalid project name: ${projectName}`)
+    }
+
+    const projectPaths = this.getProjectPaths(normalizedName)
+
+    // Check if project already exists
+    if (await this.reader.fileExists(projectPaths.context)) {
+      throw new Error(`Project already exists: ${normalizedName}`)
+    }
+
+    await this.writer.createProjectStructure(projectPaths.root, normalizedName)
+    this.logger.info({ projectName: normalizedName }, 'Project created')
+  }
+
+  /**
+   * Get project context
+   */
+  async getProjectContext(projectName: string): Promise<MarkdownFile | null> {
+    const projectPaths = this.getProjectPaths(projectName)
+
+    try {
+      return await this.reader.readMarkdownFile(projectPaths.context)
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Update project progress
+   */
+  async updateProgress(
+    projectName: string,
+    updates: {
+      status?: string
+      currentPhase?: string
+      completionPercentage?: number
+      content?: string
+    }
+  ): Promise<void> {
+    const projectPaths = this.getProjectPaths(projectName)
+
+    const frontmatterUpdates: Partial<Frontmatter> = {}
+    if (updates.status) frontmatterUpdates.status = updates.status
+    if (updates.currentPhase) frontmatterUpdates.current_phase = updates.currentPhase
+    if (updates.completionPercentage !== undefined) {
+      frontmatterUpdates.completion_percentage = updates.completionPercentage
+    }
+
+    await this.writer.updateFrontmatter(projectPaths.progress, frontmatterUpdates)
+
+    if (updates.content) {
+      await this.writer.appendContent(projectPaths.progress, updates.content)
+    }
+
+    this.logger.info({ projectName, updates }, 'Progress updated')
+  }
+
+  /**
+   * Add a decision to the decision log
+   */
+  async addDecision(
+    projectName: string,
+    decision: {
+      title: string
+      context: string
+      decision: string
+      consequences: string
+      status?: string
+    }
+  ): Promise<void> {
+    const projectPaths = this.getProjectPaths(projectName)
+
+    // Read current decisions to get count
+    const decisionsFile = await this.reader.readMarkdownFile(projectPaths.decisions)
+    const currentCount = FrontmatterUtils.getDecisionCount(decisionsFile.frontmatter)
+    const newCount = currentCount + 1
+
+    // Format the decision entry
+    const today = new Date().toISOString().split('T')[0]
+    const decisionEntry = `
+## Decision ${newCount}: ${decision.title}
+
+**Date:** ${today}
+**Status:** ${decision.status || 'accepted'}
+**Context:** ${decision.context}
+
+### Decision
+${decision.decision}
+
+### Consequences
+${decision.consequences}
+
+---`
+
+    // Update frontmatter with new count
+    await this.writer.updateFrontmatter(projectPaths.decisions, {
+      decision_count: newCount,
+      last_updated: today
+    })
+
+    // Append the decision
+    await this.writer.appendContent(projectPaths.decisions, decisionEntry)
+
+    this.logger.info(
+      { projectName, decisionNumber: newCount, title: decision.title },
+      'Decision added'
+    )
+  }
+
+  /**
+   * Search across the vault
+   */
+  async search(options: QueryOptions): Promise<QueryResult[]> {
+    const { results } = await this.query.query(this.config.root, options)
+    return results
+  }
+
+  /**
+   * Get all projects
+   */
+  async listProjects(): Promise<string[]> {
+    return this.reader.getProjectDirectories(this.paths.projects)
+  }
+
+  /**
+   * Get project metadata
+   */
+  async getProjectMetadata(projectName: string): Promise<{
+    name: string
+    status: string
+    techStack: string[]
+    tags: string[]
+    currentPhase: string
+    completionPercentage: number
+  } | null> {
+    const context = await this.getProjectContext(projectName)
+    if (!context) return null
+
+    const projectPaths = this.getProjectPaths(projectName)
+    let progress: MarkdownFile | null = null
+
+    try {
+      progress = await this.reader.readMarkdownFile(projectPaths.progress)
+    } catch {
+      // Progress file might not exist
+    }
+
+    return {
+      name: projectName,
+      status: FrontmatterUtils.getStatus(context.frontmatter) || 'unknown',
+      techStack: FrontmatterUtils.getTechStack(context.frontmatter),
+      tags: FrontmatterUtils.getTags(context.frontmatter),
+      currentPhase: progress
+        ? FrontmatterUtils.getCurrentPhase(progress.frontmatter) || 'unknown'
+        : 'unknown',
+      completionPercentage: progress
+        ? FrontmatterUtils.getCompletionPercentage(progress.frontmatter)
+        : 0
+    }
+  }
+
+  /**
+   * Cleanup resources
+   */
+  async cleanup(): Promise<void> {
+    this.stopWatching()
+    this.reader.clearCache()
+
+    // Clean old backups
+    await this.writer.cleanOldBackups()
+
+    this.logger.info('Vault manager cleaned up')
+  }
+
+  /**
+   * Get vault statistics
+   */
+  async getStats(): Promise<{
+    projectCount: number
+    totalFiles: number
+    cacheStats: { size: number; files: string[] }
+    watcherStatus: { watching: string[]; activeDebounces: number }
+  }> {
+    const projects = await this.listProjects()
+    const allFiles = await this.reader.readDirectory(this.paths.projects, true)
+
+    return {
+      projectCount: projects.length,
+      totalFiles: allFiles.length,
+      cacheStats: this.reader.getCacheStats(),
+      watcherStatus: this.watcher.getStatus()
+    }
+  }
+}