ccmanager 2.8.0 → 2.9.1

package/dist/services/projectManager.js

@@ -4,6 +4,8 @@ import { promises as fs } from 'fs';
 import path from 'path';
 import { homedir } from 'os';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { Effect } from 'effect';
+import { FileSystemError, ConfigError } from '../types/errors.js';
 export class ProjectManager {
     constructor() {
         Object.defineProperty(this, "currentMode", {
@@ -111,24 +113,6 @@ export class ProjectManager {
         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];
@@ -209,47 +193,6 @@ export class ProjectManager {
         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
      */
@@ -384,6 +327,232 @@ export class ProjectManager {
         this.projectCache.set(projectPath, project);
         return project;
     }
+    // Effect-based API methods
+    /**
+     * Discover Git projects in the specified directory using Effect
+     *
+     * Recursively scans the directory for Git repositories with parallel processing.
+     * Caches results for improved performance.
+     *
+     * @param {string} projectsDir - Root directory to search for Git projects
+     * @returns {Effect.Effect<GitProject[], FileSystemError, never>} Effect containing discovered projects or FileSystemError
+     *
+     * @example
+     * ```typescript
+     * import {Effect} from 'effect';
+     * import {projectManager} from './services/projectManager.js';
+     *
+     * // Discover projects with error handling
+     * const projects = await Effect.runPromise(
+     *   Effect.catchAll(
+     *     projectManager.instance.discoverProjectsEffect('/home/user/projects'),
+     *     (error) => {
+     *       console.error(`Discovery failed: ${error.cause}`);
+     *       return Effect.succeed([]); // Return empty array on error
+     *     }
+     *   )
+     * );
+     *
+     * console.log(`Found ${projects.length} git repositories`);
+     * ```
+     */
+    discoverProjectsEffect(projectsDir) {
+        return Effect.tryPromise({
+            try: async () => {
+                // 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
+                const projects = [];
+                const projectMap = new Map();
+                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 instanceof FileSystemError) {
+                    return error;
+                }
+                const nodeError = error;
+                const cause = nodeError.code === 'ENOENT'
+                    ? `Projects directory does not exist: ${projectsDir}`
+                    : String(error);
+                return new FileSystemError({
+                    operation: 'read',
+                    path: projectsDir,
+                    cause,
+                });
+            },
+        });
+    }
+    /**
+     * Load recent projects from cache using Effect
+     *
+     * Reads and parses the recent projects JSON file. Returns empty array if file doesn't exist.
+     *
+     * @returns {Effect.Effect<RecentProject[], FileSystemError | ConfigError, never>} Effect containing recent projects or error
+     *
+     * @example
+     * ```typescript
+     * import {Effect} from 'effect';
+     * import {projectManager} from './services/projectManager.js';
+     *
+     * // Load recent projects with error handling
+     * const recent = await Effect.runPromise(
+     *   Effect.match(
+     *     projectManager.instance.loadRecentProjectsEffect(),
+     *     {
+     *       onFailure: (error) => {
+     *         if (error._tag === 'ConfigError') {
+     *           console.error(`Parse error: ${error.details}`);
+     *         } else {
+     *           console.error(`File error: ${error.cause}`);
+     *         }
+     *         return [];
+     *       },
+     *       onSuccess: (projects) => projects
+     *     }
+     *   )
+     * );
+     * ```
+     */
+    loadRecentProjectsEffect() {
+        return Effect.try({
+            try: () => {
+                if (existsSync(this.dataPath)) {
+                    const data = readFileSync(this.dataPath, 'utf-8');
+                    try {
+                        const parsed = JSON.parse(data);
+                        return parsed || [];
+                    }
+                    catch (parseError) {
+                        throw new ConfigError({
+                            configPath: this.dataPath,
+                            reason: 'parse',
+                            details: String(parseError),
+                        });
+                    }
+                }
+                return [];
+            },
+            catch: error => {
+                if (error instanceof ConfigError) {
+                    return error;
+                }
+                return new FileSystemError({
+                    operation: 'read',
+                    path: this.dataPath,
+                    cause: String(error),
+                });
+            },
+        });
+    }
+    /**
+     * Save recent projects to cache using Effect
+     *
+     * Writes the recent projects array to JSON file.
+     *
+     * @param {RecentProject[]} projects - Recent projects to save
+     * @returns {Effect.Effect<void, FileSystemError, never>} Effect that succeeds or fails with FileSystemError
+     *
+     * @example
+     * ```typescript
+     * import {Effect} from 'effect';
+     * import {projectManager} from './services/projectManager.js';
+     *
+     * const recentProjects = [
+     *   { path: '/home/user/project1', name: 'project1', lastAccessed: Date.now() }
+     * ];
+     *
+     * // Save with error recovery
+     * await Effect.runPromise(
+     *   Effect.catchAll(
+     *     projectManager.instance.saveRecentProjectsEffect(recentProjects),
+     *     (error) => {
+     *       console.error(`Failed to save: ${error.cause}`);
+     *       return Effect.void; // Continue despite error
+     *     }
+     *   )
+     * );
+     * ```
+     */
+    saveRecentProjectsEffect(projects) {
+        return Effect.try({
+            try: () => {
+                writeFileSync(this.dataPath, JSON.stringify(projects, null, 2));
+            },
+            catch: error => {
+                return new FileSystemError({
+                    operation: 'write',
+                    path: this.dataPath,
+                    cause: String(error),
+                });
+            },
+        });
+    }
+    /**
+     * Refresh projects list (Effect version)
+     * @returns Effect with void or FileSystemError
+     */
+    refreshProjectsEffect() {
+        return Effect.flatMap(Effect.try({
+            try: () => {
+                if (!this.projectsDir) {
+                    throw new FileSystemError({
+                        operation: 'read',
+                        path: '',
+                        cause: 'Projects directory not configured',
+                    });
+                }
+                return this.projectsDir;
+            },
+            catch: error => {
+                if (error instanceof FileSystemError) {
+                    return error;
+                }
+                return new FileSystemError({
+                    operation: 'read',
+                    path: '',
+                    cause: String(error),
+                });
+            },
+        }), projectsDir => Effect.flatMap(this.discoverProjectsEffect(projectsDir), projects => Effect.sync(() => {
+            this.projects = projects;
+            // 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;
+                }
+            }
+        })));
+    }
 }
 // Recent projects
 Object.defineProperty(ProjectManager, "MAX_RECENT_PROJECTS", {

package/dist/services/projectManager.test.js

@@ -1,6 +1,7 @@
 import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
 import * as fs from 'fs';
 import * as path from 'path';
+import { Effect, Either } from 'effect';
 // Mock modules before any other imports that might use them
 vi.mock('fs');
 vi.mock('os', () => ({
@@ -10,6 +11,7 @@ vi.mock('os', () => ({
 // Now import modules that depend on the mocked modules
 import { ProjectManager } from './projectManager.js';
 import { ENV_VARS } from '../constants/env.js';
+import { FileSystemError, ConfigError } from '../types/errors.js';
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const mockFs = fs;
 describe('ProjectManager', () => {
@@ -78,7 +80,7 @@ describe('ProjectManager', () => {
                     throw new Error('Not found');
                 }),
             };
-            await projectManager.refreshProjects();
+            await Effect.runPromise(projectManager.refreshProjectsEffect());
             expect(projectManager.projects).toHaveLength(2);
             expect(projectManager.projects[0]).toMatchObject({
                 name: 'project1',
@@ -95,7 +97,15 @@ describe('ProjectManager', () => {
             mockFs.promises = {
                 access: vi.fn().mockRejectedValue({ code: 'ENOENT' }),
             };
-            await expect(projectManager.refreshProjects()).rejects.toThrow(`Projects directory does not exist: ${mockProjectsDir}`);
+            const result = await Effect.runPromise(Effect.either(projectManager.refreshProjectsEffect()));
+            expect(Either.isLeft(result)).toBe(true);
+            if (Either.isLeft(result)) {
+                const error = result.left;
+                expect(error._tag).toBe('FileSystemError');
+                if (error._tag === 'FileSystemError') {
+                    expect(error.cause).toContain(`Projects directory does not exist: ${mockProjectsDir}`);
+                }
+            }
         });
     });
     describe('recent projects', () => {
@@ -338,4 +348,234 @@ describe('ProjectManager', () => {
             expect(isValid).toBe(false);
         });
     });
+    describe('Effect-based API', () => {
+        beforeEach(() => {
+            process.env[ENV_VARS.MULTI_PROJECT_ROOT] = mockProjectsDir;
+            projectManager = new ProjectManager();
+        });
+        describe('discoverProjectsEffect', () => {
+            it('should return Effect with projects on success', async () => {
+                // Mock file system for project discovery
+                mockFs.promises = {
+                    access: vi.fn().mockResolvedValue(undefined),
+                    readdir: vi.fn().mockImplementation((dir) => {
+                        if (dir === mockProjectsDir) {
+                            return Promise.resolve([
+                                { name: 'project1', isDirectory: () => true },
+                                { name: 'project2', isDirectory: () => true },
+                            ]);
+                        }
+                        return Promise.resolve([]);
+                    }),
+                    stat: vi.fn().mockImplementation((path) => {
+                        if (path.endsWith('.git')) {
+                            return Promise.resolve({
+                                isDirectory: () => true,
+                                isFile: () => false,
+                            });
+                        }
+                        throw new Error('Not found');
+                    }),
+                };
+                const effect = projectManager.discoverProjectsEffect(mockProjectsDir);
+                const projects = await Effect.runPromise(effect);
+                expect(projects).toHaveLength(2);
+                expect(projects[0]).toMatchObject({
+                    name: 'project1',
+                    isValid: true,
+                });
+            });
+            it('should return Effect with FileSystemError when directory does not exist', async () => {
+                mockFs.promises = {
+                    access: vi.fn().mockRejectedValue({ code: 'ENOENT' }),
+                };
+                const effect = projectManager.discoverProjectsEffect(mockProjectsDir);
+                const result = await Effect.runPromise(Effect.either(effect));
+                expect(Either.isLeft(result)).toBe(true);
+                if (Either.isLeft(result)) {
+                    const error = result.left;
+                    expect(error._tag).toBe('FileSystemError');
+                    expect(error).toBeInstanceOf(FileSystemError);
+                    expect(error.operation).toBe('read');
+                    expect(error.path).toBe(mockProjectsDir);
+                }
+            });
+            it('should use Effect.all for parallel project scanning', async () => {
+                mockFs.promises = {
+                    access: vi.fn().mockResolvedValue(undefined),
+                    readdir: vi.fn().mockImplementation(() => {
+                        return Promise.resolve([
+                            { name: 'project1', isDirectory: () => true },
+                            { name: 'project2', isDirectory: () => true },
+                            { name: 'project3', isDirectory: () => true },
+                        ]);
+                    }),
+                    stat: vi.fn().mockImplementation((path) => {
+                        if (path.endsWith('.git')) {
+                            return Promise.resolve({
+                                isDirectory: () => true,
+                                isFile: () => false,
+                            });
+                        }
+                        throw new Error('Not found');
+                    }),
+                };
+                const effect = projectManager.discoverProjectsEffect(mockProjectsDir);
+                const projects = await Effect.runPromise(effect);
+                expect(projects).toHaveLength(3);
+            });
+        });
+        describe('loadRecentProjectsEffect', () => {
+            it('should return Effect with recent projects on success', async () => {
+                const mockRecentProjects = [
+                    {
+                        path: '/path/to/project1',
+                        name: 'project1',
+                        lastAccessed: Date.now(),
+                    },
+                    {
+                        path: '/path/to/project2',
+                        name: 'project2',
+                        lastAccessed: Date.now() - 1000,
+                    },
+                ];
+                mockFs.readFileSync.mockReturnValue(JSON.stringify(mockRecentProjects));
+                mockFs.existsSync.mockReturnValue(true);
+                // Re-create to load recent projects
+                projectManager = new ProjectManager();
+                const effect = projectManager.loadRecentProjectsEffect();
+                const projects = await Effect.runPromise(effect);
+                expect(projects).toHaveLength(2);
+                expect(projects[0]?.name).toBe('project1');
+            });
+            it('should return Effect with FileSystemError when file read fails', async () => {
+                mockFs.existsSync.mockReturnValue(true);
+                mockFs.readFileSync.mockImplementation(() => {
+                    throw new Error('Permission denied');
+                });
+                projectManager = new ProjectManager();
+                const effect = projectManager.loadRecentProjectsEffect();
+                const result = await Effect.runPromise(Effect.either(effect));
+                expect(Either.isLeft(result)).toBe(true);
+                if (Either.isLeft(result)) {
+                    const error = result.left;
+                    expect(error._tag).toBe('FileSystemError');
+                    expect(error).toBeInstanceOf(FileSystemError);
+                    if (error._tag === 'FileSystemError') {
+                        expect(error.operation).toBe('read');
+                    }
+                }
+            });
+            it('should return Effect with ConfigError when JSON parse fails', async () => {
+                mockFs.existsSync.mockReturnValue(true);
+                mockFs.readFileSync.mockReturnValue('invalid json{');
+                projectManager = new ProjectManager();
+                const effect = projectManager.loadRecentProjectsEffect();
+                const result = await Effect.runPromise(Effect.either(effect));
+                expect(Either.isLeft(result)).toBe(true);
+                if (Either.isLeft(result)) {
+                    const error = result.left;
+                    expect(error._tag).toBe('ConfigError');
+                    expect(error).toBeInstanceOf(ConfigError);
+                    if (error._tag === 'ConfigError') {
+                        expect(error.reason).toBe('parse');
+                    }
+                }
+            });
+            it('should use Effect.catchAll for fallback to empty cache on error', async () => {
+                mockFs.existsSync.mockReturnValue(false);
+                projectManager = new ProjectManager();
+                const effect = projectManager.loadRecentProjectsEffect();
+                const projects = await Effect.runPromise(Effect.catchAll(effect, () => Effect.succeed([])));
+                expect(projects).toEqual([]);
+            });
+        });
+        describe('saveRecentProjectsEffect', () => {
+            it('should return Effect with void on success', async () => {
+                mockFs.writeFileSync.mockImplementation(() => { });
+                projectManager = new ProjectManager();
+                const projects = [
+                    {
+                        path: '/path/to/project1',
+                        name: 'project1',
+                        lastAccessed: Date.now(),
+                    },
+                ];
+                const effect = projectManager.saveRecentProjectsEffect(projects);
+                await Effect.runPromise(effect);
+                expect(mockFs.writeFileSync).toHaveBeenCalledWith(mockRecentProjectsPath, expect.any(String));
+            });
+            it('should return Effect with FileSystemError when write fails', async () => {
+                mockFs.writeFileSync.mockImplementation(() => {
+                    throw new Error('Disk full');
+                });
+                projectManager = new ProjectManager();
+                const projects = [
+                    {
+                        path: '/path/to/project1',
+                        name: 'project1',
+                        lastAccessed: Date.now(),
+                    },
+                ];
+                const effect = projectManager.saveRecentProjectsEffect(projects);
+                const result = await Effect.runPromise(Effect.either(effect));
+                expect(Either.isLeft(result)).toBe(true);
+                if (Either.isLeft(result)) {
+                    const error = result.left;
+                    expect(error._tag).toBe('FileSystemError');
+                    expect(error).toBeInstanceOf(FileSystemError);
+                    expect(error.operation).toBe('write');
+                }
+            });
+        });
+        describe('refreshProjectsEffect', () => {
+            it('should return Effect with void on success', async () => {
+                mockFs.promises = {
+                    access: vi.fn().mockResolvedValue(undefined),
+                    readdir: vi.fn().mockImplementation(() => {
+                        return Promise.resolve([
+                            { name: 'project1', isDirectory: () => true },
+                        ]);
+                    }),
+                    stat: vi.fn().mockImplementation((path) => {
+                        if (path.endsWith('.git')) {
+                            return Promise.resolve({
+                                isDirectory: () => true,
+                                isFile: () => false,
+                            });
+                        }
+                        throw new Error('Not found');
+                    }),
+                };
+                const effect = projectManager.refreshProjectsEffect();
+                await Effect.runPromise(effect);
+                expect(projectManager.projects).toHaveLength(1);
+            });
+            it('should return Effect with FileSystemError when projects directory not configured', async () => {
+                // Create without multi-project root
+                delete process.env[ENV_VARS.MULTI_PROJECT_ROOT];
+                projectManager = new ProjectManager();
+                const effect = projectManager.refreshProjectsEffect();
+                const result = await Effect.runPromise(Effect.either(effect));
+                expect(Either.isLeft(result)).toBe(true);
+                if (Either.isLeft(result)) {
+                    const error = result.left;
+                    expect(error._tag).toBe('FileSystemError');
+                    expect(error).toBeInstanceOf(FileSystemError);
+                }
+            });
+            it('should return Effect with FileSystemError or GitError on discovery failure', async () => {
+                mockFs.promises = {
+                    access: vi.fn().mockRejectedValue({ code: 'ENOENT' }),
+                };
+                const effect = projectManager.refreshProjectsEffect();
+                const result = await Effect.runPromise(Effect.either(effect));
+                expect(Either.isLeft(result)).toBe(true);
+                if (Either.isLeft(result)) {
+                    const error = result.left;
+                    expect(['FileSystemError', 'GitError']).toContain(error._tag);
+                }
+            });
+        });
+    });
 });

package/dist/services/sessionManager.d.ts

@@ -1,5 +1,7 @@
 import { Session, SessionManager as ISessionManager, SessionState, DevcontainerConfig } from '../types/index.js';
 import { EventEmitter } from 'events';
+import { Effect } from 'effect';
+import { ProcessError, ConfigError } from '../types/errors.js';
 export interface SessionCounts {
     idle: number;
     busy: number;
@@ -16,7 +18,25 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private createSessionId;
     private createTerminal;
     private createSessionInternal;
-    createSessionWithPreset(worktreePath: string, presetId?: string): Promise<Session>;
+    /**
+     * Create session with command preset using Effect-based error handling
+     *
+     * @param {string} worktreePath - Path to the worktree
+     * @param {string} [presetId] - Optional preset ID, uses default if not provided
+     * @returns {Effect.Effect<Session, ProcessError | ConfigError, never>} Effect that may fail with ProcessError (spawn failure) or ConfigError (invalid preset)
+     *
+     * @example
+     * ```typescript
+     * // Use Effect.match for type-safe error handling
+     * const result = await Effect.runPromise(
+     *   Effect.match(effect, {
+     *     onFailure: (error) => ({ type: 'error', message: error.message }),
+     *     onSuccess: (session) => ({ type: 'success', data: session })
+     *   })
+     * );
+     * ```
+     */
+    createSessionWithPresetEffect(worktreePath: string, presetId?: string): Effect.Effect<Session, ProcessError | ConfigError, never>;
     private setupDataHandler;
     /**
      * Sets up exit handler for the session process.
@@ -31,8 +51,30 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     getSession(worktreePath: string): Session | undefined;
     setSessionActive(worktreePath: string, active: boolean): void;
     destroySession(worktreePath: string): void;
+    /**
+     * Terminate session and cleanup resources using Effect-based error handling
+     *
+     * @param {string} worktreePath - Path to the worktree
+     * @returns {Effect.Effect<void, ProcessError, never>} Effect that may fail with ProcessError if session does not exist or cleanup fails
+     *
+     * @example
+     * ```typescript
+     * // Terminate session with error handling
+     * const result = await Effect.runPromise(
+     *   Effect.match(effect, {
+     *     onFailure: (error) => ({ type: 'error', message: error.message }),
+     *     onSuccess: () => ({ type: 'success' })
+     *   })
+     * );
+     * ```
+     */
+    terminateSessionEffect(worktreePath: string): Effect.Effect<void, ProcessError, never>;
     getAllSessions(): Session[];
-    createSessionWithDevcontainer(worktreePath: string, devcontainerConfig: DevcontainerConfig, presetId?: string): Promise<Session>;
+    /**
+     * Create session with devcontainer integration using Effect-based error handling
+     * @returns Effect that may fail with ProcessError (container/spawn failure) or ConfigError (invalid preset)
+     */
+    createSessionWithDevcontainerEffect(worktreePath: string, devcontainerConfig: DevcontainerConfig, presetId?: string): Effect.Effect<Session, ProcessError | ConfigError, never>;
     destroy(): void;
     static getSessionCounts(sessions: Session[]): SessionCounts;
     static formatSessionCounts(counts: SessionCounts): string;

package/dist/services/sessionManager.effect.test.d.ts

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