claude-brain 0.14.2 → 0.14.4

package/src/automation/project-detector.ts

@@ -1,310 +1,310 @@
-/**
- * Project Detector
- * Phase 12: Advanced Memory & Intelligent Automation
- *
- * Automatically detects project from working directory
- */
-
-import fs from 'fs/promises'
-import path from 'path'
-import type { Logger } from 'pino'
-import type { VaultManager } from '@/vault'
-
-export interface DetectedProject {
-  name: string
-  path: string
-  confidence: number
-  indicators: string[]
-}
-
-export class ProjectDetector {
-  private logger: Logger
-  private vault: VaultManager
-
-  constructor(logger: Logger, vault: VaultManager) {
-    this.logger = logger.child({ component: 'project-detector' })
-    this.vault = vault
-  }
-
-  /**
-   * Detect project from working directory
-   */
-  async detectProject(workingDir: string): Promise<DetectedProject | null> {
-    this.logger.debug({ workingDir }, 'Detecting project')
-
-    try {
-      // Get all projects from vault
-      const vaultProjects = await this.vault.listProjects()
-
-      // Check for exact match by directory name
-      const dirName = path.basename(workingDir)
-      if (vaultProjects.includes(dirName)) {
-        this.logger.info({ project: dirName }, 'Exact directory match found')
-        return {
-          name: dirName,
-          path: workingDir,
-          confidence: 1.0,
-          indicators: ['exact-directory-match']
-        }
-      }
-
-      // Check for package.json or git config
-      const projectName = await this.detectFromFiles(workingDir)
-      if (projectName && vaultProjects.includes(projectName)) {
-        this.logger.info({ project: projectName }, 'Package/git match found')
-        return {
-          name: projectName,
-          path: workingDir,
-          confidence: 0.9,
-          indicators: ['package-json-name']
-        }
-      }
-
-      // Check for fuzzy match
-      const fuzzyMatch = this.fuzzyMatchProject(dirName, vaultProjects)
-      if (fuzzyMatch) {
-        this.logger.info({ project: fuzzyMatch.name, confidence: fuzzyMatch.confidence }, 'Fuzzy match found')
-        return {
-          name: fuzzyMatch.name,
-          path: workingDir,
-          confidence: fuzzyMatch.confidence,
-          indicators: ['fuzzy-match']
-        }
-      }
-
-      // Check parent directories
-      const parentMatch = await this.checkParentDirectories(workingDir, vaultProjects)
-      if (parentMatch) {
-        return parentMatch
-      }
-
-      this.logger.debug({ workingDir }, 'No project detected')
-      return null
-    } catch (error) {
-      this.logger.warn({ error, workingDir }, 'Error detecting project')
-      return null
-    }
-  }
-
-  /**
-   * Detect project name from files
-   */
-  private async detectFromFiles(workingDir: string): Promise<string | null> {
-    // Check package.json
-    try {
-      const packagePath = path.join(workingDir, 'package.json')
-      const packageContent = await fs.readFile(packagePath, 'utf-8')
-      const packageJson = JSON.parse(packageContent)
-
-      if (packageJson.name) {
-        // Clean package name (remove scope)
-        const name = packageJson.name.replace(/^@[^/]+\//, '')
-        return name
-      }
-    } catch {
-      // No package.json or invalid JSON
-    }
-
-    // Check pyproject.toml for Python projects
-    try {
-      const pyprojectPath = path.join(workingDir, 'pyproject.toml')
-      const pyprojectContent = await fs.readFile(pyprojectPath, 'utf-8')
-
-      const nameMatch = pyprojectContent.match(/name\s*=\s*"([^"]+)"/)
-      if (nameMatch) {
-        return nameMatch[1]
-      }
-    } catch {
-      // No pyproject.toml
-    }
-
-    // Check Cargo.toml for Rust projects
-    try {
-      const cargoPath = path.join(workingDir, 'Cargo.toml')
-      const cargoContent = await fs.readFile(cargoPath, 'utf-8')
-
-      const nameMatch = cargoContent.match(/name\s*=\s*"([^"]+)"/)
-      if (nameMatch) {
-        return nameMatch[1]
-      }
-    } catch {
-      // No Cargo.toml
-    }
-
-    // Check .git/config for remote URL
-    try {
-      const gitConfigPath = path.join(workingDir, '.git', 'config')
-      const gitConfig = await fs.readFile(gitConfigPath, 'utf-8')
-
-      // Extract repo name from URL
-      const urlMatch = gitConfig.match(/url\s*=\s*.+\/([^/\n]+?)(?:\.git)?[\s\n]/)
-      if (urlMatch) {
-        return urlMatch[1].trim()
-      }
-    } catch {
-      // No .git/config
-    }
-
-    return null
-  }
-
-  /**
-   * Fuzzy match project name
-   */
-  private fuzzyMatchProject(
-    dirName: string,
-    projects: string[]
-  ): { name: string; confidence: number } | null {
-    const dirLower = dirName.toLowerCase()
-
-    let bestMatch: { name: string; confidence: number } | null = null
-
-    for (const project of projects) {
-      const projectLower = project.toLowerCase()
-
-      // Check if directory contains project name
-      if (dirLower.includes(projectLower)) {
-        const confidence = projectLower.length / dirLower.length
-        if (!bestMatch || confidence > bestMatch.confidence) {
-          bestMatch = { name: project, confidence: Math.min(0.8, confidence) }
-        }
-        continue
-      }
-
-      // Check if project name contains directory
-      if (projectLower.includes(dirLower)) {
-        const confidence = dirLower.length / projectLower.length
-        if (!bestMatch || confidence > bestMatch.confidence) {
-          bestMatch = { name: project, confidence: Math.min(0.7, confidence) }
-        }
-        continue
-      }
-
-      // Check Levenshtein distance
-      const distance = this.levenshteinDistance(dirLower, projectLower)
-      const maxLen = Math.max(dirLower.length, projectLower.length)
-
-      if (distance <= 3 && distance < maxLen * 0.3) {
-        const confidence = 1 - (distance / maxLen)
-        if (!bestMatch || confidence > bestMatch.confidence) {
-          bestMatch = { name: project, confidence: Math.min(0.6, confidence) }
-        }
-      }
-    }
-
-    return bestMatch
-  }
-
-  /**
-   * Check parent directories for project match
-   */
-  private async checkParentDirectories(
-    workingDir: string,
-    projects: string[]
-  ): Promise<DetectedProject | null> {
-    let currentDir = workingDir
-    let depth = 0
-    const maxDepth = 3
-
-    while (depth < maxDepth) {
-      const parentDir = path.dirname(currentDir)
-
-      if (parentDir === currentDir) {
-        // Reached root
-        break
-      }
-
-      const parentName = path.basename(parentDir)
-
-      if (projects.includes(parentName)) {
-        return {
-          name: parentName,
-          path: parentDir,
-          confidence: 0.7 - (depth * 0.1),
-          indicators: ['parent-directory-match', `depth-${depth + 1}`]
-        }
-      }
-
-      currentDir = parentDir
-      depth++
-    }
-
-    return null
-  }
-
-  /**
-   * Calculate Levenshtein distance between two strings
-   */
-  private levenshteinDistance(a: string, b: string): number {
-    const matrix: number[][] = []
-
-    for (let i = 0; i <= b.length; i++) {
-      matrix[i] = [i]
-    }
-
-    for (let j = 0; j <= a.length; j++) {
-      matrix[0][j] = j
-    }
-
-    for (let i = 1; i <= b.length; i++) {
-      for (let j = 1; j <= a.length; j++) {
-        if (b.charAt(i - 1) === a.charAt(j - 1)) {
-          matrix[i][j] = matrix[i - 1][j - 1]
-        } else {
-          matrix[i][j] = Math.min(
-            matrix[i - 1][j - 1] + 1,
-            matrix[i][j - 1] + 1,
-            matrix[i - 1][j] + 1
-          )
-        }
-      }
-    }
-
-    return matrix[b.length][a.length]
-  }
-
-  /**
-   * Check if a project has any existing memories.
-   * Returns true if no memories found (i.e., it's a new project).
-   */
-  async isNewProject(projectName: string): Promise<boolean> {
-    try {
-      const projects = await this.vault.listProjects()
-      return !projects.includes(projectName)
-    } catch {
-      return true
-    }
-  }
-
-  /**
-   * Get project suggestions based on working directory
-   */
-  async getSuggestions(workingDir: string, limit: number = 3): Promise<DetectedProject[]> {
-    const suggestions: DetectedProject[] = []
-    const vaultProjects = await this.vault.listProjects()
-
-    const dirName = path.basename(workingDir).toLowerCase()
-
-    for (const project of vaultProjects) {
-      const projectLower = project.toLowerCase()
-
-      // Calculate similarity
-      const distance = this.levenshteinDistance(dirName, projectLower)
-      const maxLen = Math.max(dirName.length, projectLower.length)
-      const similarity = 1 - (distance / maxLen)
-
-      if (similarity > 0.3) {
-        suggestions.push({
-          name: project,
-          path: workingDir,
-          confidence: similarity,
-          indicators: ['suggestion']
-        })
-      }
-    }
-
-    return suggestions
-      .sort((a, b) => b.confidence - a.confidence)
-      .slice(0, limit)
-  }
-}
+/**
+ * Project Detector
+ * Phase 12: Advanced Memory & Intelligent Automation
+ *
+ * Automatically detects project from working directory
+ */
+
+import fs from 'fs/promises'
+import path from 'path'
+import type { Logger } from 'pino'
+import type { VaultManager } from '@/vault'
+
+export interface DetectedProject {
+  name: string
+  path: string
+  confidence: number
+  indicators: string[]
+}
+
+export class ProjectDetector {
+  private logger: Logger
+  private vault: VaultManager
+
+  constructor(logger: Logger, vault: VaultManager) {
+    this.logger = logger.child({ component: 'project-detector' })
+    this.vault = vault
+  }
+
+  /**
+   * Detect project from working directory
+   */
+  async detectProject(workingDir: string): Promise<DetectedProject | null> {
+    this.logger.debug({ workingDir }, 'Detecting project')
+
+    try {
+      // Get all projects from vault
+      const vaultProjects = await this.vault.listProjects()
+
+      // Check for exact match by directory name
+      const dirName = path.basename(workingDir)
+      if (vaultProjects.includes(dirName)) {
+        this.logger.info({ project: dirName }, 'Exact directory match found')
+        return {
+          name: dirName,
+          path: workingDir,
+          confidence: 1.0,
+          indicators: ['exact-directory-match']
+        }
+      }
+
+      // Check for package.json or git config
+      const projectName = await this.detectFromFiles(workingDir)
+      if (projectName && vaultProjects.includes(projectName)) {
+        this.logger.info({ project: projectName }, 'Package/git match found')
+        return {
+          name: projectName,
+          path: workingDir,
+          confidence: 0.9,
+          indicators: ['package-json-name']
+        }
+      }
+
+      // Check for fuzzy match
+      const fuzzyMatch = this.fuzzyMatchProject(dirName, vaultProjects)
+      if (fuzzyMatch) {
+        this.logger.info({ project: fuzzyMatch.name, confidence: fuzzyMatch.confidence }, 'Fuzzy match found')
+        return {
+          name: fuzzyMatch.name,
+          path: workingDir,
+          confidence: fuzzyMatch.confidence,
+          indicators: ['fuzzy-match']
+        }
+      }
+
+      // Check parent directories
+      const parentMatch = await this.checkParentDirectories(workingDir, vaultProjects)
+      if (parentMatch) {
+        return parentMatch
+      }
+
+      this.logger.debug({ workingDir }, 'No project detected')
+      return null
+    } catch (error) {
+      this.logger.warn({ error, workingDir }, 'Error detecting project')
+      return null
+    }
+  }
+
+  /**
+   * Detect project name from files
+   */
+  private async detectFromFiles(workingDir: string): Promise<string | null> {
+    // Check package.json
+    try {
+      const packagePath = path.join(workingDir, 'package.json')
+      const packageContent = await fs.readFile(packagePath, 'utf-8')
+      const packageJson = JSON.parse(packageContent)
+
+      if (packageJson.name) {
+        // Clean package name (remove scope)
+        const name = packageJson.name.replace(/^@[^/]+\//, '')
+        return name
+      }
+    } catch {
+      // No package.json or invalid JSON
+    }
+
+    // Check pyproject.toml for Python projects
+    try {
+      const pyprojectPath = path.join(workingDir, 'pyproject.toml')
+      const pyprojectContent = await fs.readFile(pyprojectPath, 'utf-8')
+
+      const nameMatch = pyprojectContent.match(/name\s*=\s*"([^"]+)"/)
+      if (nameMatch) {
+        return nameMatch[1]
+      }
+    } catch {
+      // No pyproject.toml
+    }
+
+    // Check Cargo.toml for Rust projects
+    try {
+      const cargoPath = path.join(workingDir, 'Cargo.toml')
+      const cargoContent = await fs.readFile(cargoPath, 'utf-8')
+
+      const nameMatch = cargoContent.match(/name\s*=\s*"([^"]+)"/)
+      if (nameMatch) {
+        return nameMatch[1]
+      }
+    } catch {
+      // No Cargo.toml
+    }
+
+    // Check .git/config for remote URL
+    try {
+      const gitConfigPath = path.join(workingDir, '.git', 'config')
+      const gitConfig = await fs.readFile(gitConfigPath, 'utf-8')
+
+      // Extract repo name from URL
+      const urlMatch = gitConfig.match(/url\s*=\s*.+\/([^/\n]+?)(?:\.git)?[\s\n]/)
+      if (urlMatch) {
+        return urlMatch[1].trim()
+      }
+    } catch {
+      // No .git/config
+    }
+
+    return null
+  }
+
+  /**
+   * Fuzzy match project name
+   */
+  private fuzzyMatchProject(
+    dirName: string,
+    projects: string[]
+  ): { name: string; confidence: number } | null {
+    const dirLower = dirName.toLowerCase()
+
+    let bestMatch: { name: string; confidence: number } | null = null
+
+    for (const project of projects) {
+      const projectLower = project.toLowerCase()
+
+      // Check if directory contains project name
+      if (dirLower.includes(projectLower)) {
+        const confidence = projectLower.length / dirLower.length
+        if (!bestMatch || confidence > bestMatch.confidence) {
+          bestMatch = { name: project, confidence: Math.min(0.8, confidence) }
+        }
+        continue
+      }
+
+      // Check if project name contains directory
+      if (projectLower.includes(dirLower)) {
+        const confidence = dirLower.length / projectLower.length
+        if (!bestMatch || confidence > bestMatch.confidence) {
+          bestMatch = { name: project, confidence: Math.min(0.7, confidence) }
+        }
+        continue
+      }
+
+      // Check Levenshtein distance
+      const distance = this.levenshteinDistance(dirLower, projectLower)
+      const maxLen = Math.max(dirLower.length, projectLower.length)
+
+      if (distance <= 3 && distance < maxLen * 0.3) {
+        const confidence = 1 - (distance / maxLen)
+        if (!bestMatch || confidence > bestMatch.confidence) {
+          bestMatch = { name: project, confidence: Math.min(0.6, confidence) }
+        }
+      }
+    }
+
+    return bestMatch
+  }
+
+  /**
+   * Check parent directories for project match
+   */
+  private async checkParentDirectories(
+    workingDir: string,
+    projects: string[]
+  ): Promise<DetectedProject | null> {
+    let currentDir = workingDir
+    let depth = 0
+    const maxDepth = 3
+
+    while (depth < maxDepth) {
+      const parentDir = path.dirname(currentDir)
+
+      if (parentDir === currentDir) {
+        // Reached root
+        break
+      }
+
+      const parentName = path.basename(parentDir)
+
+      if (projects.includes(parentName)) {
+        return {
+          name: parentName,
+          path: parentDir,
+          confidence: 0.7 - (depth * 0.1),
+          indicators: ['parent-directory-match', `depth-${depth + 1}`]
+        }
+      }
+
+      currentDir = parentDir
+      depth++
+    }
+
+    return null
+  }
+
+  /**
+   * Calculate Levenshtein distance between two strings
+   */
+  private levenshteinDistance(a: string, b: string): number {
+    const matrix: number[][] = []
+
+    for (let i = 0; i <= b.length; i++) {
+      matrix[i] = [i]
+    }
+
+    for (let j = 0; j <= a.length; j++) {
+      matrix[0][j] = j
+    }
+
+    for (let i = 1; i <= b.length; i++) {
+      for (let j = 1; j <= a.length; j++) {
+        if (b.charAt(i - 1) === a.charAt(j - 1)) {
+          matrix[i][j] = matrix[i - 1][j - 1]
+        } else {
+          matrix[i][j] = Math.min(
+            matrix[i - 1][j - 1] + 1,
+            matrix[i][j - 1] + 1,
+            matrix[i - 1][j] + 1
+          )
+        }
+      }
+    }
+
+    return matrix[b.length][a.length]
+  }
+
+  /**
+   * Check if a project has any existing memories.
+   * Returns true if no memories found (i.e., it's a new project).
+   */
+  async isNewProject(projectName: string): Promise<boolean> {
+    try {
+      const projects = await this.vault.listProjects()
+      return !projects.includes(projectName)
+    } catch {
+      return true
+    }
+  }
+
+  /**
+   * Get project suggestions based on working directory
+   */
+  async getSuggestions(workingDir: string, limit: number = 3): Promise<DetectedProject[]> {
+    const suggestions: DetectedProject[] = []
+    const vaultProjects = await this.vault.listProjects()
+
+    const dirName = path.basename(workingDir).toLowerCase()
+
+    for (const project of vaultProjects) {
+      const projectLower = project.toLowerCase()
+
+      // Calculate similarity
+      const distance = this.levenshteinDistance(dirName, projectLower)
+      const maxLen = Math.max(dirName.length, projectLower.length)
+      const similarity = 1 - (distance / maxLen)
+
+      if (similarity > 0.3) {
+        suggestions.push({
+          name: project,
+          path: workingDir,
+          confidence: similarity,
+          indicators: ['suggestion']
+        })
+      }
+    }
+
+    return suggestions
+      .sort((a, b) => b.confidence - a.confidence)
+      .slice(0, limit)
+  }
+}