@dynamicu/chromedebug-mcp 2.2.0

package/src/services/project-manager.js

@@ -0,0 +1,415 @@
+/**
+ * ProjectManager - Project-local directory management for Chrome Debug
+ * 
+ * Provides intelligent project detection and creates project-local directory
+ * structures for Chrome Debug data (.chromedebug/ in project root).
+ * 
+ * Key Features:
+ * - Automatic project type detection (npm, git, python, etc.)
+ * - Project-local directory structure creation
+ * - Automatic .gitignore management
+ * - Fallback to global mode when not in a valid project
+ * - Path validation and security
+ */
+
+import { promises as fs, existsSync as fsExistsSync } from 'fs';
+import path from 'path';
+import os from 'os';
+
+export class ProjectManager {
+  constructor() {
+    this.projectInfo = null;
+    this.projectStructure = null;
+    this.initialized = false;
+  }
+
+  /**
+   * Detects if current working directory is part of a valid project
+   * @param {string} startPath - Starting path for project detection (defaults to cwd)
+   * @returns {ProjectInfo|null} Project information or null if not in project
+   */
+  detectProject(startPath = process.cwd()) {
+    try {
+      const resolvedPath = path.resolve(startPath);
+      const projectRoot = this.findProjectRoot(resolvedPath);
+      
+      if (!projectRoot) {
+        console.log('[ProjectManager] No valid project detected from:', resolvedPath);
+        return null;
+      }
+
+      // Determine project type based on markers
+      const markers = this.getProjectMarkers(projectRoot);
+      const projectType = this.determineProjectType(markers);
+
+      this.projectInfo = {
+        projectDir: projectRoot,
+        type: projectType,
+        hasMarkers: markers
+      };
+
+      console.log(`[ProjectManager] Detected ${projectType} project at: ${projectRoot}`);
+      console.log(`[ProjectManager] Project markers found: ${markers.join(', ')}`);
+      
+      return this.projectInfo;
+    } catch (error) {
+      console.warn('[ProjectManager] Error during project detection:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Recursively searches up directory tree for project markers
+   * @param {string} currentPath - Current path to check
+   * @returns {string|null} Project root path or null if not found
+   */
+  findProjectRoot(currentPath) {
+    const rootPath = path.parse(currentPath).root;
+    
+    // Don't go beyond root directory
+    if (currentPath === rootPath) {
+      return null;
+    }
+
+    try {
+      // Check for project markers in current directory
+      const markers = this.getProjectMarkers(currentPath);
+      
+      if (markers.length > 0) {
+        return currentPath;
+      }
+
+      // Move up one directory and continue searching
+      const parentPath = path.dirname(currentPath);
+      
+      // Avoid infinite recursion at root
+      if (parentPath === currentPath) {
+        return null;
+      }
+      
+      return this.findProjectRoot(parentPath);
+    } catch (error) {
+      // Directory might not exist or be accessible
+      return null;
+    }
+  }
+
+  /**
+   * Gets list of project markers found in a directory
+   * @param {string} dirPath - Directory to check for markers
+   * @returns {string[]} Array of found marker file/directory names
+   */
+  getProjectMarkers(dirPath) {
+    const markers = [
+      'package.json',      // Node.js
+      '.git',             // Git repository (directory or file for worktrees)
+      'requirements.txt',  // Python
+      'pyproject.toml',   // Python (modern)
+      'Pipfile',          // Python pipenv
+      'Cargo.toml',       // Rust
+      'pom.xml',          // Maven (Java)
+      'build.gradle',     // Gradle (Java/Kotlin)
+      'go.mod',           // Go
+      'composer.json',    // PHP Composer
+      'Gemfile',          // Ruby
+      '.project',         // Eclipse project
+      'CMakeLists.txt',   // CMake
+      'Makefile'          // Make
+    ];
+
+    const found = [];
+
+    for (const marker of markers) {
+      try {
+        const markerPath = path.join(dirPath, marker);
+        
+        if (this.existsSync(markerPath)) {
+          found.push(marker);
+        }
+      } catch (error) {
+        // Ignore access errors for individual markers
+        continue;
+      }
+    }
+
+    return found;
+  }
+
+  /**
+   * Synchronously check if path exists (safer than fs.existsSync)
+   * @param {string} filePath - Path to check
+   * @returns {boolean} True if path exists
+   */
+  existsSync(filePath) {
+    try {
+      return fsExistsSync(filePath);
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Determines project type based on found markers
+   * @param {string[]} markers - Found project markers
+   * @returns {string} Project type identifier
+   */
+  determineProjectType(markers) {
+    // Priority order for type detection
+    if (markers.includes('package.json')) return 'npm';
+    if (markers.includes('requirements.txt') || markers.includes('pyproject.toml') || markers.includes('Pipfile')) return 'python';
+    if (markers.includes('Cargo.toml')) return 'rust';
+    if (markers.includes('pom.xml') || markers.includes('build.gradle')) return 'java';
+    if (markers.includes('go.mod')) return 'go';
+    if (markers.includes('composer.json')) return 'php';
+    if (markers.includes('Gemfile')) return 'ruby';
+    if (markers.includes('.git')) return 'git';
+    if (markers.includes('CMakeLists.txt') || markers.includes('Makefile')) return 'native';
+    
+    return 'generic';
+  }
+
+  /**
+   * Gets the project directory (must call detectProject first)
+   * @returns {string} Project directory path
+   * @throws {Error} If no project detected
+   */
+  getProjectDir() {
+    if (!this.projectInfo) {
+      throw new Error('No project detected. Call detectProject() first.');
+    }
+    return this.projectInfo.projectDir;
+  }
+
+  /**
+   * Validates if a path is a valid project directory
+   * @param {string} dirPath - Path to validate
+   * @returns {boolean} True if valid project directory
+   */
+  isValidProject(dirPath) {
+    if (!dirPath || typeof dirPath !== 'string') {
+      return false;
+    }
+
+    try {
+      const resolvedPath = path.resolve(dirPath);
+      const markers = this.getProjectMarkers(resolvedPath);
+      return markers.length > 0;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Initializes project-local directory structure
+   * Creates .chromedebug/ directory with subdirectories and .gitignore entry
+   * @returns {Promise<void>}
+   */
+  async initializeProjectStructure() {
+    if (!this.projectInfo) {
+      throw new Error('No project detected. Call detectProject() first.');
+    }
+
+    const projectDir = this.projectInfo.projectDir;
+    
+    // Create project structure configuration
+    this.projectStructure = {
+      baseDir: path.join(projectDir, '.chromedebug'),
+      sessionsDir: path.join(projectDir, '.chromedebug', 'sessions'),
+      databaseDir: path.join(projectDir, '.chromedebug', 'database'),
+      configDir: path.join(projectDir, '.chromedebug', 'config'),
+      logsDir: path.join(projectDir, '.chromedebug', 'logs')
+    };
+
+    console.log(`[ProjectManager] Initializing project structure in: ${this.projectStructure.baseDir}`);
+
+    try {
+      // Create all necessary directories
+      await fs.mkdir(this.projectStructure.baseDir, { recursive: true });
+      await fs.mkdir(this.projectStructure.sessionsDir, { recursive: true });
+      await fs.mkdir(this.projectStructure.databaseDir, { recursive: true });
+      await fs.mkdir(this.projectStructure.configDir, { recursive: true });
+      await fs.mkdir(this.projectStructure.logsDir, { recursive: true });
+
+      // Add .chromedebug to .gitignore if project has git
+      if (this.projectInfo.hasMarkers.includes('.git')) {
+        await this.updateGitignore(projectDir);
+      }
+
+      console.log('[ProjectManager] Project structure initialized successfully');
+      console.log('[ProjectManager] Structure:', this.projectStructure);
+      
+      this.initialized = true;
+    } catch (error) {
+      console.error('[ProjectManager] Failed to initialize project structure:', error);
+      throw new Error(`Project structure initialization failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Updates .gitignore to exclude .chromedebug directory
+   * @param {string} projectDir - Project directory path
+   * @returns {Promise<void>}
+   */
+  async updateGitignore(projectDir) {
+    const gitignorePath = path.join(projectDir, '.gitignore');
+    const chromePilotEntry = '.chromedebug/';
+
+    try {
+      let gitignoreContent = '';
+      let needsUpdate = true;
+
+      // Read existing .gitignore if it exists
+      try {
+        gitignoreContent = await fs.readFile(gitignorePath, 'utf8');
+        
+        // Check if .chromedebug is already ignored
+        const lines = gitignoreContent.split('\n');
+        const hasEntry = lines.some(line => 
+          line.trim() === chromePilotEntry || 
+          line.trim() === '.chromedebug' ||
+          line.trim() === '.chromedebug/*'
+        );
+        
+        if (hasEntry) {
+          needsUpdate = false;
+          console.log('[ProjectManager] .chromedebug already in .gitignore');
+        }
+      } catch (error) {
+        // .gitignore doesn't exist, will create it
+        console.log('[ProjectManager] Creating new .gitignore file');
+      }
+
+      if (needsUpdate) {
+        // Ensure content ends with newline before adding entry
+        if (gitignoreContent && !gitignoreContent.endsWith('\n')) {
+          gitignoreContent += '\n';
+        }
+
+        // Add Chrome Debug section
+        const chromePilotSection = `
+# Chrome Debug project-local data
+${chromePilotEntry}
+`;
+        
+        gitignoreContent += chromePilotSection;
+
+        await fs.writeFile(gitignorePath, gitignoreContent, 'utf8');
+        console.log('[ProjectManager] Added .chromedebug to .gitignore');
+      }
+    } catch (error) {
+      console.warn('[ProjectManager] Warning: Could not update .gitignore:', error.message);
+      // Don't fail initialization if .gitignore update fails
+    }
+  }
+
+  /**
+   * Gets the project structure paths (must initialize first)
+   * @returns {ProjectStructure} Project structure object
+   * @throws {Error} If not initialized
+   */
+  getProjectStructure() {
+    if (!this.projectStructure) {
+      throw new Error('Project structure not initialized. Call initializeProjectStructure() first.');
+    }
+    return { ...this.projectStructure };
+  }
+
+  /**
+   * Gets project-local database path
+   * @returns {string} Database file path
+   */
+  getProjectDatabasePath() {
+    if (!this.projectStructure) {
+      throw new Error('Project structure not initialized');
+    }
+    return path.join(this.projectStructure.databaseDir, 'chromedebug.db');
+  }
+
+  /**
+   * Gets project-local config path
+   * @returns {string} Config file path
+   */
+  getProjectConfigPath() {
+    if (!this.projectStructure) {
+      throw new Error('Project structure not initialized');
+    }
+    return path.join(this.projectStructure.configDir, 'config.json');
+  }
+
+  /**
+   * Gets project-local sessions directory path
+   * @returns {string} Sessions directory path
+   */
+  getProjectSessionsDir() {
+    if (!this.projectStructure) {
+      throw new Error('Project structure not initialized');
+    }
+    return this.projectStructure.sessionsDir;
+  }
+
+  /**
+   * Gets project-local logs directory path
+   * @returns {string} Logs directory path  
+   */
+  getProjectLogsDir() {
+    if (!this.projectStructure) {
+      throw new Error('Project structure not initialized');
+    }
+    return this.projectStructure.logsDir;
+  }
+
+  /**
+   * Checks if project mode is available (project detected and initialized)
+   * @returns {boolean} True if project mode is available
+   */
+  isProjectModeAvailable() {
+    return this.projectInfo !== null && this.initialized;
+  }
+
+  /**
+   * Gets fallback global directories for when not in project mode
+   * @returns {ProjectStructure} Global structure paths
+   */
+  getGlobalStructure() {
+    const globalBaseDir = path.join(os.tmpdir(), 'chromedebug-global');
+    
+    return {
+      baseDir: globalBaseDir,
+      sessionsDir: path.join(globalBaseDir, 'sessions'),
+      databaseDir: path.join(process.cwd(), 'data'), // Existing global database location
+      configDir: path.join(process.cwd(), 'config'),  // Existing global config location
+      logsDir: globalBaseDir
+    };
+  }
+
+  /**
+   * Resets the project manager state (useful for testing)
+   */
+  reset() {
+    this.projectInfo = null;
+    this.projectStructure = null;
+    this.initialized = false;
+  }
+
+  /**
+   * Gets current mode ('project' or 'global')
+   * @returns {string} Current operational mode
+   */
+  getCurrentMode() {
+    return this.isProjectModeAvailable() ? 'project' : 'global';
+  }
+
+  /**
+   * Gets debug information about current state
+   * @returns {object} Debug information
+   */
+  getDebugInfo() {
+    return {
+      mode: this.getCurrentMode(),
+      projectInfo: this.projectInfo,
+      projectStructure: this.projectStructure,
+      initialized: this.initialized,
+      cwd: process.cwd()
+    };
+  }
+}