claude-brain 0.30.1 → 0.30.3

package/src/context/standards-manager.ts

@@ -1,287 +1,287 @@
-/**
- * Code Standards Manager
- * Maintains and injects project coding standards consistently
- */
-
-import type { Logger } from 'pino'
-import type { VaultManager } from '@/vault'
-import type { CodeStandards, LanguageStandards, FrameworkStandards, NamingConventions, FormattingRules, TestingStandards, DocumentationStandards, SecurityStandards } from './types'
-
-export class StandardsManager {
-  private logger: Logger
-  private vault: VaultManager
-  private globalStandards: CodeStandards | null = null
-  private projectStandards: Map<string, CodeStandards> = new Map()
-
-  constructor(logger: Logger, vault: VaultManager) {
-    this.logger = logger.child({ component: 'standards-manager' })
-    this.vault = vault
-  }
-
-  async loadGlobalStandards(): Promise<CodeStandards> {
-    if (this.globalStandards) {
-      return this.globalStandards
-    }
-
-    try {
-      const globalPath = `${this.vault.paths.global}/standards.md`
-      const file = await this.vault.reader.readMarkdownFile(globalPath)
-
-      this.globalStandards = this.parseStandards(file.content)
-      this.logger.info('Global standards loaded')
-
-      return this.globalStandards
-    } catch (error) {
-      this.logger.warn('No global standards found, using defaults')
-      this.globalStandards = this.getDefaultStandards()
-      return this.globalStandards
-    }
-  }
-
-  async getProjectStandards(projectName: string): Promise<CodeStandards> {
-    if (this.projectStandards.has(projectName)) {
-      return this.projectStandards.get(projectName)!
-    }
-
-    try {
-      const projectPaths = this.vault.getProjectPaths(projectName)
-      const file = await this.vault.reader.readMarkdownFile(projectPaths.standards)
-      const projectStandards = this.parseStandards(file.content)
-
-      const globalStandards = await this.loadGlobalStandards()
-
-      const merged = this.mergeStandards(globalStandards, projectStandards)
-
-      this.projectStandards.set(projectName, merged)
-
-      this.logger.info({ projectName }, 'Project standards loaded')
-      return merged
-
-    } catch (error) {
-      this.logger.warn({ projectName }, 'No project standards found, using global')
-      return await this.loadGlobalStandards()
-    }
-  }
-
-  async getLanguageStandards(
-    projectName: string,
-    language: string
-  ): Promise<LanguageStandards | null> {
-    const standards = await this.getProjectStandards(projectName)
-    return standards.languages.find(l => l.language === language) || null
-  }
-
-  async getFrameworkStandards(
-    projectName: string,
-    framework: string
-  ): Promise<FrameworkStandards | null> {
-    const standards = await this.getProjectStandards(projectName)
-    return standards.frameworks.find(f => f.framework === framework) || null
-  }
-
-  private parseStandards(content: string): CodeStandards {
-    return {
-      languages: this.parseLanguageStandards(content),
-      frameworks: this.parseFrameworkStandards(content),
-      naming: this.parseNamingConventions(content) as unknown as NamingConventions,
-      formatting: this.parseFormattingRules(content) as unknown as FormattingRules,
-      testing: this.parseTestingStandards(content) as unknown as TestingStandards,
-      documentation: this.parseDocumentationStandards(content) as unknown as DocumentationStandards,
-      security: this.parseSecurityStandards(content) as unknown as SecurityStandards
-    }
-  }
-
-  private parseLanguageStandards(content: string): LanguageStandards[] {
-    const languages: LanguageStandards[] = []
-
-    const langRegex = /##\s+(TypeScript|Python|JavaScript|Java|Go|Rust)\s+/gi
-
-    let match
-    while ((match = langRegex.exec(content)) !== null) {
-      const language = match[1]!
-      const sectionStart = match.index
-      const nextSection = content.indexOf('##', sectionStart + 1)
-      const sectionEnd = nextSection === -1 ? content.length : nextSection
-      const section = content.slice(sectionStart, sectionEnd)
-
-      languages.push({
-        language,
-        version: this.extractVersion(section),
-        style: this.extractStyle(section),
-        linting: {},
-        conventions: this.extractConventions(section),
-        antiPatterns: this.extractAntiPatterns(section)
-      })
-    }
-
-    return languages
-  }
-
-  private parseFrameworkStandards(_content: string): FrameworkStandards[] {
-    return []
-  }
-
-  private extractVersion(section: string): string {
-    const match = /Version:\s*(.+?)(?:\n|$)/i.exec(section)
-    return match ? match[1]!.trim() : 'latest'
-  }
-
-  private extractStyle(section: string): string {
-    const match = /Style:\s*(.+?)(?:\n|$)/i.exec(section)
-    return match ? match[1]!.trim() : 'standard'
-  }
-
-  private extractConventions(section: string): string[] {
-    const conventions: string[] = []
-    const listRegex = /^[-*]\s+(.+)$/gm
-
-    let match
-    while ((match = listRegex.exec(section)) !== null) {
-      conventions.push(match[1]!.trim())
-    }
-
-    return conventions
-  }
-
-  private extractAntiPatterns(section: string): string[] {
-    const antiPatternsSection = /Anti-Patterns?:(.+?)(?=\n##|$)/is.exec(section)
-    if (!antiPatternsSection) return []
-
-    const patterns: string[] = []
-    const listRegex = /^[-*]\s+(.+)$/gm
-
-    let match
-    while ((match = listRegex.exec(antiPatternsSection[1]!)) !== null) {
-      patterns.push(match[1]!.trim())
-    }
-
-    return patterns
-  }
-
-  private parseNamingConventions(_content: string): Record<string, unknown> {
-    return {}
-  }
-
-  private parseFormattingRules(_content: string): Record<string, unknown> {
-    return {}
-  }
-
-  private parseTestingStandards(_content: string): Record<string, unknown> {
-    return {}
-  }
-
-  private parseDocumentationStandards(_content: string): Record<string, unknown> {
-    return {}
-  }
-
-  private parseSecurityStandards(_content: string): Record<string, unknown> {
-    return {}
-  }
-
-  private mergeStandards(
-    base: CodeStandards,
-    override: CodeStandards
-  ): CodeStandards {
-    return {
-      languages: this.mergeLanguageStandards(base.languages, override.languages),
-      frameworks: this.mergeFrameworkStandards(base.frameworks, override.frameworks),
-      naming: { ...base.naming, ...override.naming },
-      formatting: { ...base.formatting, ...override.formatting },
-      testing: { ...base.testing, ...override.testing },
-      documentation: { ...base.documentation, ...override.documentation },
-      security: { ...base.security, ...override.security }
-    }
-  }
-
-  private mergeLanguageStandards(
-    base: LanguageStandards[],
-    override: LanguageStandards[]
-  ): LanguageStandards[] {
-    const merged = [...base]
-
-    for (const overrideStd of override) {
-      const index = merged.findIndex(s => s.language === overrideStd.language)
-      if (index >= 0) {
-        merged[index] = overrideStd
-      } else {
-        merged.push(overrideStd)
-      }
-    }
-
-    return merged
-  }
-
-  private mergeFrameworkStandards(
-    base: FrameworkStandards[],
-    override: FrameworkStandards[]
-  ): FrameworkStandards[] {
-    const merged = [...base]
-
-    for (const overrideStd of override) {
-      const index = merged.findIndex(s => s.framework === overrideStd.framework)
-      if (index >= 0) {
-        merged[index] = overrideStd
-      } else {
-        merged.push(overrideStd)
-      }
-    }
-
-    return merged
-  }
-
-  private getDefaultStandards(): CodeStandards {
-    return {
-      languages: [
-        {
-          language: 'TypeScript',
-          version: 'latest',
-          style: 'standard',
-          linting: {},
-          conventions: [
-            'Use strict mode',
-            'Prefer const over let',
-            'Use async/await over promises',
-            'Add JSDoc comments for public APIs'
-          ],
-          antiPatterns: [
-            'Using any type',
-            'Ignoring error handling',
-            'Deep nesting'
-          ]
-        },
-        {
-          language: 'JavaScript',
-          version: 'ES2022+',
-          style: 'standard',
-          linting: {},
-          conventions: [
-            'Use strict mode',
-            'Prefer const over let',
-            'Use async/await over promises',
-            'Use optional chaining and nullish coalescing',
-            'Add JSDoc comments for public APIs'
-          ],
-          antiPatterns: [
-            'Using var',
-            'Callback hell',
-            'Ignoring error handling',
-            'Deep nesting',
-            'Mutating function arguments'
-          ]
-        }
-      ],
-      frameworks: [],
-      naming: {} as NamingConventions,
-      formatting: {} as FormattingRules,
-      testing: {} as TestingStandards,
-      documentation: {} as DocumentationStandards,
-      security: {} as SecurityStandards
-    }
-  }
-
-  clearCache(): void {
-    this.projectStandards.clear()
-    this.globalStandards = null
-    this.logger.debug('Standards cache cleared')
-  }
-}
+/**
+ * Code Standards Manager
+ * Maintains and injects project coding standards consistently
+ */
+
+import type { Logger } from 'pino'
+import type { VaultManager } from '@/vault'
+import type { CodeStandards, LanguageStandards, FrameworkStandards, NamingConventions, FormattingRules, TestingStandards, DocumentationStandards, SecurityStandards } from './types'
+
+export class StandardsManager {
+  private logger: Logger
+  private vault: VaultManager
+  private globalStandards: CodeStandards | null = null
+  private projectStandards: Map<string, CodeStandards> = new Map()
+
+  constructor(logger: Logger, vault: VaultManager) {
+    this.logger = logger.child({ component: 'standards-manager' })
+    this.vault = vault
+  }
+
+  async loadGlobalStandards(): Promise<CodeStandards> {
+    if (this.globalStandards) {
+      return this.globalStandards
+    }
+
+    try {
+      const globalPath = `${this.vault.paths.global}/standards.md`
+      const file = await this.vault.reader.readMarkdownFile(globalPath)
+
+      this.globalStandards = this.parseStandards(file.content)
+      this.logger.info('Global standards loaded')
+
+      return this.globalStandards
+    } catch (error) {
+      this.logger.warn('No global standards found, using defaults')
+      this.globalStandards = this.getDefaultStandards()
+      return this.globalStandards
+    }
+  }
+
+  async getProjectStandards(projectName: string): Promise<CodeStandards> {
+    if (this.projectStandards.has(projectName)) {
+      return this.projectStandards.get(projectName)!
+    }
+
+    try {
+      const projectPaths = this.vault.getProjectPaths(projectName)
+      const file = await this.vault.reader.readMarkdownFile(projectPaths.standards)
+      const projectStandards = this.parseStandards(file.content)
+
+      const globalStandards = await this.loadGlobalStandards()
+
+      const merged = this.mergeStandards(globalStandards, projectStandards)
+
+      this.projectStandards.set(projectName, merged)
+
+      this.logger.info({ projectName }, 'Project standards loaded')
+      return merged
+
+    } catch (error) {
+      this.logger.warn({ projectName }, 'No project standards found, using global')
+      return await this.loadGlobalStandards()
+    }
+  }
+
+  async getLanguageStandards(
+    projectName: string,
+    language: string
+  ): Promise<LanguageStandards | null> {
+    const standards = await this.getProjectStandards(projectName)
+    return standards.languages.find(l => l.language === language) || null
+  }
+
+  async getFrameworkStandards(
+    projectName: string,
+    framework: string
+  ): Promise<FrameworkStandards | null> {
+    const standards = await this.getProjectStandards(projectName)
+    return standards.frameworks.find(f => f.framework === framework) || null
+  }
+
+  private parseStandards(content: string): CodeStandards {
+    return {
+      languages: this.parseLanguageStandards(content),
+      frameworks: this.parseFrameworkStandards(content),
+      naming: this.parseNamingConventions(content) as unknown as NamingConventions,
+      formatting: this.parseFormattingRules(content) as unknown as FormattingRules,
+      testing: this.parseTestingStandards(content) as unknown as TestingStandards,
+      documentation: this.parseDocumentationStandards(content) as unknown as DocumentationStandards,
+      security: this.parseSecurityStandards(content) as unknown as SecurityStandards
+    }
+  }
+
+  private parseLanguageStandards(content: string): LanguageStandards[] {
+    const languages: LanguageStandards[] = []
+
+    const langRegex = /##\s+(TypeScript|Python|JavaScript|Java|Go|Rust)\s+/gi
+
+    let match
+    while ((match = langRegex.exec(content)) !== null) {
+      const language = match[1]!
+      const sectionStart = match.index
+      const nextSection = content.indexOf('##', sectionStart + 1)
+      const sectionEnd = nextSection === -1 ? content.length : nextSection
+      const section = content.slice(sectionStart, sectionEnd)
+
+      languages.push({
+        language,
+        version: this.extractVersion(section),
+        style: this.extractStyle(section),
+        linting: {},
+        conventions: this.extractConventions(section),
+        antiPatterns: this.extractAntiPatterns(section)
+      })
+    }
+
+    return languages
+  }
+
+  private parseFrameworkStandards(_content: string): FrameworkStandards[] {
+    return []
+  }
+
+  private extractVersion(section: string): string {
+    const match = /Version:\s*(.+?)(?:\n|$)/i.exec(section)
+    return match ? match[1]!.trim() : 'latest'
+  }
+
+  private extractStyle(section: string): string {
+    const match = /Style:\s*(.+?)(?:\n|$)/i.exec(section)
+    return match ? match[1]!.trim() : 'standard'
+  }
+
+  private extractConventions(section: string): string[] {
+    const conventions: string[] = []
+    const listRegex = /^[-*]\s+(.+)$/gm
+
+    let match
+    while ((match = listRegex.exec(section)) !== null) {
+      conventions.push(match[1]!.trim())
+    }
+
+    return conventions
+  }
+
+  private extractAntiPatterns(section: string): string[] {
+    const antiPatternsSection = /Anti-Patterns?:(.+?)(?=\n##|$)/is.exec(section)
+    if (!antiPatternsSection) return []
+
+    const patterns: string[] = []
+    const listRegex = /^[-*]\s+(.+)$/gm
+
+    let match
+    while ((match = listRegex.exec(antiPatternsSection[1]!)) !== null) {
+      patterns.push(match[1]!.trim())
+    }
+
+    return patterns
+  }
+
+  private parseNamingConventions(_content: string): Record<string, unknown> {
+    return {}
+  }
+
+  private parseFormattingRules(_content: string): Record<string, unknown> {
+    return {}
+  }
+
+  private parseTestingStandards(_content: string): Record<string, unknown> {
+    return {}
+  }
+
+  private parseDocumentationStandards(_content: string): Record<string, unknown> {
+    return {}
+  }
+
+  private parseSecurityStandards(_content: string): Record<string, unknown> {
+    return {}
+  }
+
+  private mergeStandards(
+    base: CodeStandards,
+    override: CodeStandards
+  ): CodeStandards {
+    return {
+      languages: this.mergeLanguageStandards(base.languages, override.languages),
+      frameworks: this.mergeFrameworkStandards(base.frameworks, override.frameworks),
+      naming: { ...base.naming, ...override.naming },
+      formatting: { ...base.formatting, ...override.formatting },
+      testing: { ...base.testing, ...override.testing },
+      documentation: { ...base.documentation, ...override.documentation },
+      security: { ...base.security, ...override.security }
+    }
+  }
+
+  private mergeLanguageStandards(
+    base: LanguageStandards[],
+    override: LanguageStandards[]
+  ): LanguageStandards[] {
+    const merged = [...base]
+
+    for (const overrideStd of override) {
+      const index = merged.findIndex(s => s.language === overrideStd.language)
+      if (index >= 0) {
+        merged[index] = overrideStd
+      } else {
+        merged.push(overrideStd)
+      }
+    }
+
+    return merged
+  }
+
+  private mergeFrameworkStandards(
+    base: FrameworkStandards[],
+    override: FrameworkStandards[]
+  ): FrameworkStandards[] {
+    const merged = [...base]
+
+    for (const overrideStd of override) {
+      const index = merged.findIndex(s => s.framework === overrideStd.framework)
+      if (index >= 0) {
+        merged[index] = overrideStd
+      } else {
+        merged.push(overrideStd)
+      }
+    }
+
+    return merged
+  }
+
+  private getDefaultStandards(): CodeStandards {
+    return {
+      languages: [
+        {
+          language: 'TypeScript',
+          version: 'latest',
+          style: 'standard',
+          linting: {},
+          conventions: [
+            'Use strict mode',
+            'Prefer const over let',
+            'Use async/await over promises',
+            'Add JSDoc comments for public APIs'
+          ],
+          antiPatterns: [
+            'Using any type',
+            'Ignoring error handling',
+            'Deep nesting'
+          ]
+        },
+        {
+          language: 'JavaScript',
+          version: 'ES2022+',
+          style: 'standard',
+          linting: {},
+          conventions: [
+            'Use strict mode',
+            'Prefer const over let',
+            'Use async/await over promises',
+            'Use optional chaining and nullish coalescing',
+            'Add JSDoc comments for public APIs'
+          ],
+          antiPatterns: [
+            'Using var',
+            'Callback hell',
+            'Ignoring error handling',
+            'Deep nesting',
+            'Mutating function arguments'
+          ]
+        }
+      ],
+      frameworks: [],
+      naming: {} as NamingConventions,
+      formatting: {} as FormattingRules,
+      testing: {} as TestingStandards,
+      documentation: {} as DocumentationStandards,
+      security: {} as SecurityStandards
+    }
+  }
+
+  clearCache(): void {
+    this.projectStandards.clear()
+    this.globalStandards = null
+    this.logger.debug('Standards cache cleared')
+  }
+}