ccmanager 1.4.4 → 2.0.0

package/dist/services/configurationManager.js

@@ -16,6 +16,12 @@ export class ConfigurationManager {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "configDir", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "config", {
             enumerable: true,
             configurable: true,
@@ -24,15 +30,16 @@ export class ConfigurationManager {
         });
         // Determine config directory based on platform
         const homeDir = homedir();
-        const configDir = process.platform === 'win32'
-            ? join(process.env['APPDATA'] || join(homeDir, 'AppData', 'Roaming'), 'ccmanager')
-            : join(homeDir, '.config', 'ccmanager');
+        this.configDir =
+            process.platform === 'win32'
+                ? join(process.env['APPDATA'] || join(homeDir, 'AppData', 'Roaming'), 'ccmanager')
+                : join(homeDir, '.config', 'ccmanager');
         // Ensure config directory exists
-        if (!existsSync(configDir)) {
-            mkdirSync(configDir, { recursive: true });
+        if (!existsSync(this.configDir)) {
+            mkdirSync(this.configDir, { recursive: true });
         }
-        this.configPath = join(configDir, 'config.json');
-        this.legacyShortcutsPath = join(configDir, 'shortcuts.json');
+        this.configPath = join(this.configDir, 'config.json');
+        this.legacyShortcutsPath = join(this.configDir, 'shortcuts.json');
         this.loadConfig();
     }
     loadConfig() {

package/dist/services/globalSessionOrchestrator.d.ts

@@ -0,0 +1,16 @@
+import { SessionManager } from './sessionManager.js';
+import { Session } from '../types/index.js';
+declare class GlobalSessionOrchestrator {
+    private static instance;
+    private projectManagers;
+    private globalManager;
+    private constructor();
+    static getInstance(): GlobalSessionOrchestrator;
+    getManagerForProject(projectPath?: string): SessionManager;
+    getAllActiveSessions(): Session[];
+    destroyAllSessions(): void;
+    destroyProjectSessions(projectPath: string): void;
+    getProjectSessions(projectPath: string): Session[];
+}
+export declare const globalSessionOrchestrator: GlobalSessionOrchestrator;
+export {};

package/dist/services/globalSessionOrchestrator.js

@@ -0,0 +1,73 @@
+import { SessionManager } from './sessionManager.js';
+class GlobalSessionOrchestrator {
+    constructor() {
+        Object.defineProperty(this, "projectManagers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "globalManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // Create a global session manager for single-project mode
+        this.globalManager = new SessionManager();
+    }
+    static getInstance() {
+        if (!GlobalSessionOrchestrator.instance) {
+            GlobalSessionOrchestrator.instance = new GlobalSessionOrchestrator();
+        }
+        return GlobalSessionOrchestrator.instance;
+    }
+    getManagerForProject(projectPath) {
+        // If no project path, return the global manager (single-project mode)
+        if (!projectPath) {
+            return this.globalManager;
+        }
+        // Get or create a session manager for this project
+        let manager = this.projectManagers.get(projectPath);
+        if (!manager) {
+            manager = new SessionManager();
+            this.projectManagers.set(projectPath, manager);
+        }
+        return manager;
+    }
+    getAllActiveSessions() {
+        const sessions = [];
+        // Get sessions from global manager
+        sessions.push(...this.globalManager.getAllSessions());
+        // Get sessions from all project managers
+        for (const manager of this.projectManagers.values()) {
+            sessions.push(...manager.getAllSessions());
+        }
+        return sessions;
+    }
+    destroyAllSessions() {
+        // Destroy sessions in global manager
+        this.globalManager.destroy();
+        // Destroy sessions in all project managers
+        for (const manager of this.projectManagers.values()) {
+            manager.destroy();
+        }
+        // Clear the project managers map
+        this.projectManagers.clear();
+    }
+    destroyProjectSessions(projectPath) {
+        const manager = this.projectManagers.get(projectPath);
+        if (manager) {
+            manager.destroy();
+            this.projectManagers.delete(projectPath);
+        }
+    }
+    getProjectSessions(projectPath) {
+        const manager = this.projectManagers.get(projectPath);
+        if (manager) {
+            return manager.getAllSessions();
+        }
+        return [];
+    }
+}
+export const globalSessionOrchestrator = GlobalSessionOrchestrator.getInstance();

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

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

package/dist/services/globalSessionOrchestrator.test.js

@@ -0,0 +1,180 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { globalSessionOrchestrator } from './globalSessionOrchestrator.js';
+// Mock SessionManager
+vi.mock('./sessionManager.js', () => {
+    class MockSessionManager {
+        constructor() {
+            Object.defineProperty(this, "sessions", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: new Map()
+            });
+        }
+        getAllSessions() {
+            return Array.from(this.sessions.values());
+        }
+        destroy() {
+            this.sessions.clear();
+        }
+        getSession(worktreePath) {
+            return this.sessions.get(worktreePath);
+        }
+        setSessionActive(_worktreePath, _active) {
+            // Mock implementation
+        }
+        destroySession(worktreePath) {
+            this.sessions.delete(worktreePath);
+        }
+        on() {
+            // Mock implementation
+        }
+        off() {
+            // Mock implementation
+        }
+        emit() {
+            // Mock implementation
+        }
+        async createSessionWithPreset(_worktreePath, _presetId) {
+            // Mock implementation
+            return {};
+        }
+        async createSessionWithDevcontainer(_worktreePath, _config, _presetId) {
+            // Mock implementation
+            return {};
+        }
+    }
+    return { SessionManager: MockSessionManager };
+});
+describe('GlobalSessionManager', () => {
+    beforeEach(() => {
+        // Clear any existing sessions
+        globalSessionOrchestrator.destroyAllSessions();
+    });
+    it('should return the same manager instance for the same project', () => {
+        const manager1 = globalSessionOrchestrator.getManagerForProject('/project1');
+        const manager2 = globalSessionOrchestrator.getManagerForProject('/project1');
+        expect(manager1).toBe(manager2);
+    });
+    it('should return different managers for different projects', () => {
+        const manager1 = globalSessionOrchestrator.getManagerForProject('/project1');
+        const manager2 = globalSessionOrchestrator.getManagerForProject('/project2');
+        expect(manager1).not.toBe(manager2);
+    });
+    it('should return global manager when no project path is provided', () => {
+        const manager1 = globalSessionOrchestrator.getManagerForProject();
+        const manager2 = globalSessionOrchestrator.getManagerForProject();
+        expect(manager1).toBe(manager2);
+    });
+    it('should get all active sessions from all managers', () => {
+        const globalManager = globalSessionOrchestrator.getManagerForProject();
+        const project1Manager = globalSessionOrchestrator.getManagerForProject('/project1');
+        const project2Manager = globalSessionOrchestrator.getManagerForProject('/project2');
+        // Add mock sessions
+        globalManager.sessions.set('global-session', {
+            id: 'global-session',
+        });
+        project1Manager.sessions.set('project1-session', {
+            id: 'project1-session',
+        });
+        project2Manager.sessions.set('project2-session', {
+            id: 'project2-session',
+        });
+        const allSessions = globalSessionOrchestrator.getAllActiveSessions();
+        expect(allSessions).toHaveLength(3);
+        const sessionIds = allSessions.map(s => s.id);
+        expect(sessionIds).toContain('global-session');
+        expect(sessionIds).toContain('project1-session');
+        expect(sessionIds).toContain('project2-session');
+    });
+    it('should destroy all sessions when destroyAllSessions is called', () => {
+        const globalManager = globalSessionOrchestrator.getManagerForProject();
+        const project1Manager = globalSessionOrchestrator.getManagerForProject('/project1');
+        // Add mock sessions
+        globalManager.sessions.set('global-session', {
+            id: 'global-session',
+        });
+        project1Manager.sessions.set('project1-session', {
+            id: 'project1-session',
+        });
+        globalSessionOrchestrator.destroyAllSessions();
+        expect(globalManager.sessions.size).toBe(0);
+        expect(project1Manager.sessions.size).toBe(0);
+    });
+    it('should destroy only project sessions when destroyProjectSessions is called', () => {
+        const globalManager = globalSessionOrchestrator.getManagerForProject();
+        const project1Manager = globalSessionOrchestrator.getManagerForProject('/project1');
+        const project2Manager = globalSessionOrchestrator.getManagerForProject('/project2');
+        // Add mock sessions
+        globalManager.sessions.set('global-session', {
+            id: 'global-session',
+        });
+        project1Manager.sessions.set('project1-session', {
+            id: 'project1-session',
+        });
+        project2Manager.sessions.set('project2-session', {
+            id: 'project2-session',
+        });
+        globalSessionOrchestrator.destroyProjectSessions('/project1');
+        // Global and project2 sessions should remain
+        expect(globalManager.sessions.size).toBe(1);
+        expect(project2Manager.sessions.size).toBe(1);
+        // project1 sessions should be cleared
+        const newProject1Manager = globalSessionOrchestrator.getManagerForProject('/project1');
+        expect(newProject1Manager).not.toBe(project1Manager); // Should be a new instance
+        expect(newProject1Manager.sessions.size).toBe(0);
+    });
+    it('should persist sessions when switching between projects', () => {
+        const project1Manager = globalSessionOrchestrator.getManagerForProject('/project1');
+        project1Manager.sessions.set('session1', {
+            id: 'session1',
+            worktreePath: '/project1/main',
+        });
+        // Switch to project2
+        const project2Manager = globalSessionOrchestrator.getManagerForProject('/project2');
+        project2Manager.sessions.set('session2', {
+            id: 'session2',
+            worktreePath: '/project2/main',
+        });
+        // Switch back to project1
+        const project1ManagerAgain = globalSessionOrchestrator.getManagerForProject('/project1');
+        // Session should still exist
+        expect(project1ManagerAgain).toBe(project1Manager);
+        expect(project1ManagerAgain.sessions.get('session1')).toEqual({
+            id: 'session1',
+            worktreePath: '/project1/main',
+        });
+    });
+    it('should get sessions for a specific project', () => {
+        const project1Manager = globalSessionOrchestrator.getManagerForProject('/project1');
+        const project2Manager = globalSessionOrchestrator.getManagerForProject('/project2');
+        // Add mock sessions with different states
+        project1Manager.sessions.set('session1', {
+            id: 'session1',
+            state: 'idle',
+        });
+        project1Manager.sessions.set('session2', {
+            id: 'session2',
+            state: 'busy',
+        });
+        project1Manager.sessions.set('session3', {
+            id: 'session3',
+            state: 'waiting',
+        });
+        project2Manager.sessions.set('session4', {
+            id: 'session4',
+            state: 'idle',
+        });
+        const project1Sessions = globalSessionOrchestrator.getProjectSessions('/project1');
+        const project2Sessions = globalSessionOrchestrator.getProjectSessions('/project2');
+        const project3Sessions = globalSessionOrchestrator.getProjectSessions('/project3'); // non-existent
+        expect(project1Sessions).toHaveLength(3);
+        expect(project2Sessions).toHaveLength(1);
+        expect(project3Sessions).toHaveLength(0);
+        // Verify the sessions are correct
+        const project1Ids = project1Sessions.map(s => s.id);
+        expect(project1Ids).toContain('session1');
+        expect(project1Ids).toContain('session2');
+        expect(project1Ids).toContain('session3');
+    });
+});

package/dist/services/projectManager.d.ts

@@ -0,0 +1,60 @@
+import { GitProject, IProjectManager, IWorktreeService, MenuMode, RecentProject } from '../types/index.js';
+export declare class ProjectManager implements IProjectManager {
+    currentMode: MenuMode;
+    currentProject?: GitProject;
+    projects: GitProject[];
+    private worktreeServiceCache;
+    private projectsDir?;
+    private projectCache;
+    private discoveryWorkers;
+    private static readonly MAX_RECENT_PROJECTS;
+    private recentProjects;
+    private dataPath;
+    private configDir;
+    constructor();
+    setMode(mode: MenuMode): void;
+    selectProject(project: GitProject): void;
+    getWorktreeService(projectPath?: string): IWorktreeService;
+    refreshProjects(): Promise<void>;
+    isMultiProjectEnabled(): boolean;
+    getProjectsDir(): string | undefined;
+    getCurrentProjectPath(): string;
+    clearWorktreeServiceCache(projectPath?: string): void;
+    getCachedServices(): Map<string, IWorktreeService>;
+    private loadRecentProjects;
+    private saveRecentProjects;
+    getRecentProjects(limit?: number): RecentProject[];
+    addRecentProject(project: GitProject): void;
+    clearRecentProjects(): void;
+    discoverProjects(projectsDir: string): Promise<GitProject[]>;
+    /**
+     * Fast directory discovery - similar to ghq's approach
+     */
+    private discoverDirectories;
+    /**
+     * Quick check for .git directory without running git commands
+     */
+    private hasGitDirectory;
+    /**
+     * Process directories in parallel using worker pool pattern
+     */
+    private processDirectoriesInParallel;
+    /**
+     * 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)
+     */
+    private processDirectory;
+    validateGitRepository(projectPath: string): Promise<boolean>;
+    getCachedProject(projectPath: string): GitProject | undefined;
+    refreshProject(projectPath: string): Promise<GitProject | null>;
+}
+export declare const projectManager: {
+    readonly instance: ProjectManager;
+    getRecentProjects(limit?: number): RecentProject[];
+    addRecentProject(project: GitProject): void;
+    clearRecentProjects(): void;
+    _resetForTesting(): void;
+};