ccmanager 1.4.5 → 2.1.0

package/dist/services/projectManager.js

@@ -0,0 +1,418 @@
+import { WorktreeService } from './worktreeService.js';
+import { ENV_VARS } from '../constants/env.js';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { homedir } from 'os';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+export class ProjectManager {
+    constructor() {
+        Object.defineProperty(this, "currentMode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "currentProject", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "projects", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "worktreeServiceCache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "projectsDir", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // Multi-project discovery
+        Object.defineProperty(this, "projectCache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "discoveryWorkers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 4
+        });
+        Object.defineProperty(this, "recentProjects", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "dataPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "configDir", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // Initialize mode based on environment variables
+        const multiProjectRoot = process.env[ENV_VARS.MULTI_PROJECT_ROOT];
+        this.projectsDir = process.env[ENV_VARS.MULTI_PROJECT_ROOT];
+        // Set initial mode
+        this.currentMode = multiProjectRoot ? 'multi-project' : 'normal';
+        // If in multi-project mode but no projects dir, default to normal mode
+        if (this.currentMode === 'multi-project' && !this.projectsDir) {
+            this.currentMode = 'normal';
+        }
+        // Initialize recent projects
+        const homeDir = homedir();
+        this.configDir =
+            process.platform === 'win32'
+                ? path.join(process.env['APPDATA'] || path.join(homeDir, 'AppData', 'Roaming'), 'ccmanager')
+                : path.join(homeDir, '.config', 'ccmanager');
+        // Ensure config directory exists
+        if (!existsSync(this.configDir)) {
+            mkdirSync(this.configDir, { recursive: true });
+        }
+        this.dataPath = path.join(this.configDir, 'recent-projects.json');
+        this.loadRecentProjects();
+    }
+    setMode(mode) {
+        this.currentMode = mode;
+        // Clear current project when switching to normal mode
+        if (mode === 'normal') {
+            this.currentProject = undefined;
+        }
+    }
+    selectProject(project) {
+        this.currentProject = project;
+    }
+    getWorktreeService(projectPath) {
+        // Use provided path or fall back to current project path or current directory
+        const path = projectPath || this.currentProject?.path || process.cwd();
+        // Check cache first
+        if (this.worktreeServiceCache.has(path)) {
+            return this.worktreeServiceCache.get(path);
+        }
+        // Create new service and cache it
+        const service = new WorktreeService(path);
+        this.worktreeServiceCache.set(path, service);
+        return service;
+    }
+    async refreshProjects() {
+        if (!this.projectsDir) {
+            throw new Error('Projects directory not configured');
+        }
+        // Discover projects
+        this.projects = await this.discoverProjects(this.projectsDir);
+        // Update current project if it still exists
+        if (this.currentProject) {
+            const updatedProject = this.projects.find(p => p.path === this.currentProject.path);
+            if (updatedProject) {
+                this.currentProject = updatedProject;
+            }
+            else {
+                // Current project no longer exists
+                this.currentProject = undefined;
+            }
+        }
+    }
+    // Helper methods
+    isMultiProjectEnabled() {
+        return !!process.env[ENV_VARS.MULTI_PROJECT_ROOT];
+    }
+    getProjectsDir() {
+        return this.projectsDir;
+    }
+    getCurrentProjectPath() {
+        return this.currentProject?.path || process.cwd();
+    }
+    // Clear cache for a specific project
+    clearWorktreeServiceCache(projectPath) {
+        if (projectPath) {
+            this.worktreeServiceCache.delete(projectPath);
+        }
+        else {
+            // Clear all cache
+            this.worktreeServiceCache.clear();
+        }
+    }
+    // Get all cached WorktreeService instances (useful for cleanup)
+    getCachedServices() {
+        return new Map(this.worktreeServiceCache);
+    }
+    // Recent projects methods
+    loadRecentProjects() {
+        try {
+            if (existsSync(this.dataPath)) {
+                const data = readFileSync(this.dataPath, 'utf-8');
+                this.recentProjects = JSON.parse(data) || [];
+            }
+        }
+        catch (error) {
+            console.error('Failed to load recent projects:', error);
+            this.recentProjects = [];
+        }
+    }
+    saveRecentProjects() {
+        try {
+            writeFileSync(this.dataPath, JSON.stringify(this.recentProjects, null, 2));
+        }
+        catch (error) {
+            console.error('Failed to save recent projects:', error);
+        }
+    }
+    getRecentProjects(limit) {
+        // Return recent projects sorted by last accessed
+        const sorted = this.recentProjects.sort((a, b) => b.lastAccessed - a.lastAccessed);
+        // Apply limit if specified, otherwise use default MAX_RECENT_PROJECTS
+        const maxItems = limit !== undefined ? limit : ProjectManager.MAX_RECENT_PROJECTS;
+        return maxItems > 0 ? sorted.slice(0, maxItems) : sorted;
+    }
+    addRecentProject(project) {
+        if (project.path === 'EXIT_APPLICATION') {
+            return;
+        }
+        const existingIndex = this.recentProjects.findIndex(p => p.path === project.path);
+        const recentProject = {
+            path: project.path,
+            name: project.name,
+            lastAccessed: Date.now(),
+        };
+        if (existingIndex !== -1) {
+            // Update existing project
+            this.recentProjects[existingIndex] = recentProject;
+        }
+        else {
+            // Add new project
+            this.recentProjects.unshift(recentProject);
+        }
+        // Sort by last accessed (newest first)
+        this.recentProjects = this.recentProjects.sort((a, b) => b.lastAccessed - a.lastAccessed);
+        // Save to disk
+        this.saveRecentProjects();
+    }
+    clearRecentProjects() {
+        this.recentProjects = [];
+        this.saveRecentProjects();
+    }
+    // Multi-project discovery methods
+    async discoverProjects(projectsDir) {
+        const projects = [];
+        const projectMap = new Map();
+        try {
+            // Verify the directory exists
+            await fs.access(projectsDir);
+            // Step 1: Fast concurrent directory discovery
+            const directories = await this.discoverDirectories(projectsDir);
+            // Step 2: Process directories in parallel to check if they're git repos
+            const results = await this.processDirectoriesInParallel(directories, projectsDir);
+            // Step 3: Create project objects (all results are valid git repos)
+            for (const result of results) {
+                // Handle name conflicts
+                let displayName = result.name;
+                if (projectMap.has(result.name)) {
+                    displayName = result.relativePath.replace(/[\\/\\\\]/g, '/');
+                }
+                const project = {
+                    name: displayName,
+                    path: result.path,
+                    relativePath: result.relativePath,
+                    isValid: true,
+                    error: result.error,
+                };
+                projectMap.set(displayName, project);
+            }
+            // Convert to array and sort
+            projects.push(...projectMap.values());
+            projects.sort((a, b) => a.name.localeCompare(b.name));
+            // Cache results
+            this.projectCache.clear();
+            projects.forEach(p => this.projectCache.set(p.path, p));
+            return projects;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                throw new Error(`Projects directory does not exist: ${projectsDir}`);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Fast directory discovery - similar to ghq's approach
+     */
+    async discoverDirectories(rootDir, maxDepth = 3) {
+        const tasks = [];
+        const seen = new Set();
+        const walk = async (dir, depth) => {
+            if (depth > maxDepth)
+                return;
+            try {
+                const entries = await fs.readdir(dir, { withFileTypes: true });
+                // Process entries in parallel
+                await Promise.all(entries.map(async (entry) => {
+                    if (!entry.isDirectory())
+                        return;
+                    if (entry.name.startsWith('.') && entry.name !== '.git')
+                        return;
+                    const fullPath = path.join(dir, entry.name);
+                    const relativePath = path.relative(rootDir, fullPath);
+                    // Quick check if this is a git repository
+                    const hasGitDir = await this.hasGitDirectory(fullPath);
+                    if (hasGitDir) {
+                        // Found a git repository - add to tasks and skip subdirectories
+                        if (!seen.has(fullPath)) {
+                            seen.add(fullPath);
+                            tasks.push({ path: fullPath, relativePath });
+                        }
+                        return; // Early termination - don't walk subdirectories
+                    }
+                    // Not a git repo, continue walking subdirectories
+                    await walk(fullPath, depth + 1);
+                }));
+            }
+            catch (error) {
+                // Silently skip directories we can't read
+                if (error.code !== 'EACCES') {
+                    console.error(`Error scanning directory ${dir}:`, error);
+                }
+            }
+        };
+        await walk(rootDir, 0);
+        return tasks;
+    }
+    /**
+     * Quick check for .git directory without running git commands
+     */
+    async hasGitDirectory(dirPath) {
+        try {
+            const gitPath = path.join(dirPath, '.git');
+            const stats = await fs.stat(gitPath);
+            return stats.isDirectory() || stats.isFile(); // File for worktrees
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Process directories in parallel using worker pool pattern
+     */
+    async processDirectoriesInParallel(tasks, rootDir) {
+        const results = [];
+        const queue = [...tasks];
+        const workers = [];
+        // Create worker function
+        const worker = async () => {
+            while (queue.length > 0) {
+                const task = queue.shift();
+                if (!task)
+                    break;
+                const result = await this.processDirectory(task, rootDir);
+                if (result) {
+                    results.push(result);
+                }
+            }
+        };
+        // Start workers
+        for (let i = 0; i < this.discoveryWorkers; i++) {
+            workers.push(worker());
+        }
+        // Wait for all workers to complete
+        await Promise.all(workers);
+        return results;
+    }
+    /**
+     * Process a single directory to check if it's a valid git repo
+     * @param task - The discovery task containing path information
+     * @param _rootDir - The root directory (unused)
+     * @returns A DiscoveryResult object if the directory is a valid git repository,
+     *          or null if it's not a valid git repository (will be filtered out)
+     */
+    async processDirectory(task, _rootDir) {
+        const result = {
+            path: task.path,
+            relativePath: task.relativePath,
+            name: path.basename(task.path),
+        };
+        try {
+            // Check if directory has .git (already validated in discoverDirectories)
+            // Double-check here to ensure it's still valid
+            const hasGit = await this.hasGitDirectory(task.path);
+            if (!hasGit) {
+                // Not a git repo, return null to filter it out
+                return null;
+            }
+        }
+        catch (error) {
+            result.error = `Failed to process: ${error.message}`;
+        }
+        return result;
+    }
+    async validateGitRepository(projectPath) {
+        // Simply check for .git directory existence
+        return this.hasGitDirectory(projectPath);
+    }
+    // Helper method to get a cached project
+    getCachedProject(projectPath) {
+        return this.projectCache.get(projectPath);
+    }
+    // Helper method to refresh a single project
+    async refreshProject(projectPath) {
+        if (!(await this.validateGitRepository(projectPath))) {
+            this.projectCache.delete(projectPath);
+            return null;
+        }
+        const name = path.basename(projectPath);
+        const project = {
+            name,
+            path: projectPath,
+            relativePath: name,
+            isValid: true,
+        };
+        this.projectCache.set(projectPath, project);
+        return project;
+    }
+}
+// Recent projects
+Object.defineProperty(ProjectManager, "MAX_RECENT_PROJECTS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 5
+});
+// Create singleton instance
+let _instance = null;
+export const projectManager = {
+    get instance() {
+        if (!_instance) {
+            _instance = new ProjectManager();
+        }
+        return _instance;
+    },
+    // Proxy methods to maintain backward compatibility with recentProjectsService
+    getRecentProjects(limit) {
+        return this.instance.getRecentProjects(limit);
+    },
+    addRecentProject(project) {
+        return this.instance.addRecentProject(project);
+    },
+    clearRecentProjects() {
+        return this.instance.clearRecentProjects();
+    },
+    // Reset instance for testing
+    _resetForTesting() {
+        _instance = null;
+    },
+};

package/dist/services/projectManager.test.d.ts

@@ -0,0 +1 @@
+export {};