ccmanager 2.8.0 → 2.9.0

package/dist/components/ProjectList.js

@@ -1,5 +1,6 @@
 import React, { useState, useEffect } from 'react';
 import { Box, Text, useInput } from 'ink';
+import { Effect } from 'effect';
 import SelectInput from 'ink-select-input';
 import { projectManager } from '../services/projectManager.js';
 import { MENU_ICONS } from '../constants/statusIcons.js';
@@ -14,31 +15,61 @@ const ProjectList = ({ projectsDir, onSelectProject, error, onDismissError, }) =
     const [loading, setLoading] = useState(true);
     const [loadError, setLoadError] = useState(null);
     const limit = 10;
+    // Helper function to format error messages based on error type using _tag discrimination
+    const formatErrorMessage = (error) => {
+        switch (error._tag) {
+            case 'ProcessError':
+                return `Process error: ${error.message}`;
+            case 'ConfigError':
+                return `Configuration error (${error.reason}): ${error.details}`;
+            case 'GitError':
+                return `Git command failed: ${error.command} (exit ${error.exitCode})\n${error.stderr}`;
+            case 'FileSystemError':
+                return `File ${error.operation} failed for ${error.path}: ${error.cause}`;
+            case 'ValidationError':
+                return `Validation failed for ${error.field}: ${error.constraint}`;
+        }
+    };
     // Use the search mode hook
     const displayError = error || loadError;
     const { isSearchMode, searchQuery, selectedIndex, setSearchQuery } = useSearchMode(items.length, {
         isDisabled: !!displayError,
         skipInTest: false,
     });
-    const loadProjects = async () => {
+    // Helper function to load projects with Effect-based error handling
+    const loadProjectsEffect = async (checkCancellation) => {
         setLoading(true);
         setLoadError(null);
-        try {
-            const discoveredProjects = await projectManager.instance.discoverProjects(projectsDir);
-            setProjects(discoveredProjects);
-            // Load recent projects with no limit (pass 0)
-            const allRecentProjects = projectManager.getRecentProjects(0);
-            setRecentProjects(allRecentProjects);
-        }
-        catch (err) {
-            setLoadError(err.message);
-        }
-        finally {
+        // Use Effect-based project discovery
+        const projectsEffect = projectManager.instance.discoverProjectsEffect(projectsDir);
+        // Execute the Effect and handle both success and failure cases
+        const result = await Effect.runPromise(Effect.either(projectsEffect));
+        // Check cancellation flag before updating state (if provided)
+        if (checkCancellation && checkCancellation())
+            return;
+        if (result._tag === 'Left') {
+            // Handle error using pattern matching on _tag
+            const errorMessage = formatErrorMessage(result.left);
+            setLoadError(errorMessage);
             setLoading(false);
+            return;
         }
+        // Success case - extract projects from Right
+        const discoveredProjects = result.right;
+        setProjects(discoveredProjects);
+        // Load recent projects with no limit (pass 0)
+        const allRecentProjects = projectManager.getRecentProjects(0);
+        setRecentProjects(allRecentProjects);
+        setLoading(false);
     };
+    const loadProjects = () => loadProjectsEffect();
     useEffect(() => {
-        loadProjects();
+        let cancelled = false;
+        loadProjectsEffect(() => cancelled);
+        // Cleanup function to set cancellation flag
+        return () => {
+            cancelled = true;
+        };
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [projectsDir]);
     useEffect(() => {

package/dist/components/ProjectList.recent-projects.test.js

@@ -3,6 +3,11 @@ import { render } from 'ink-testing-library';
 import { expect, describe, it, vi, beforeEach, afterEach } from 'vitest';
 import ProjectList from './ProjectList.js';
 import { projectManager } from '../services/projectManager.js';
+import { Effect } from 'effect';
+// Mock node-pty to avoid native module loading issues
+vi.mock('node-pty', () => ({
+    spawn: vi.fn(),
+}));
 // Mock ink to avoid stdin.ref issues
 vi.mock('ink', async () => {
     const actual = await vi.importActual('ink');
@@ -24,7 +29,7 @@ vi.mock('ink-select-input', async () => {
 vi.mock('../services/projectManager.js', () => ({
     projectManager: {
         instance: {
-            discoverProjects: vi.fn(),
+            discoverProjectsEffect: vi.fn(),
         },
         getRecentProjects: vi.fn(),
     },
@@ -48,7 +53,7 @@ describe('ProjectList - Recent Projects', () => {
     ];
     beforeEach(() => {
         vi.clearAllMocks();
-        vi.mocked(projectManager.instance.discoverProjects).mockResolvedValue(mockProjects);
+        vi.mocked(projectManager.instance.discoverProjectsEffect).mockReturnValue(Effect.succeed(mockProjects));
         vi.mocked(projectManager.getRecentProjects).mockReturnValue([]);
         // Mock stdin.setRawMode
         originalSetRawMode = process.stdin.setRawMode;
@@ -136,7 +141,7 @@ describe('ProjectList - Recent Projects', () => {
         // Create 10 projects
         const manyProjects = Array.from({ length: 10 }, (_, i) => createProject(`project-${i}`, `/home/user/projects/project-${i}`));
         // Mock discovered projects
-        vi.mocked(projectManager.instance.discoverProjects).mockResolvedValue(manyProjects);
+        vi.mocked(projectManager.instance.discoverProjectsEffect).mockReturnValue(Effect.succeed(manyProjects));
         // Mock more than 5 recent projects
         const manyRecentProjects = Array.from({ length: 10 }, (_, i) => ({
             name: `project-${i}`,

package/dist/components/ProjectList.test.js

@@ -1,6 +1,10 @@
 import React from 'react';
 import { render } from 'ink-testing-library';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
+// Mock node-pty to avoid native module loading issues
+vi.mock('node-pty', () => ({
+    spawn: vi.fn(),
+}));
 // Import the actual component code but skip the useInput hook
 vi.mock('ink', async () => {
     const actual = await vi.importActual('ink');
@@ -29,11 +33,16 @@ vi.mock('./TextInputWrapper.js', async () => {
         },
     };
 });
+// Mock Effect for testing
+vi.mock('effect', async () => {
+    const actual = await vi.importActual('effect');
+    return actual;
+});
 // Mock the projectManager
 vi.mock('../services/projectManager.js', () => ({
     projectManager: {
         instance: {
-            discoverProjects: vi.fn(),
+            discoverProjectsEffect: vi.fn(),
         },
         getRecentProjects: vi.fn().mockReturnValue([]),
     },
@@ -41,6 +50,7 @@ vi.mock('../services/projectManager.js', () => ({
 // Now import after mocking
 const { default: ProjectList } = await import('./ProjectList.js');
 const { projectManager } = await import('../services/projectManager.js');
+const { Effect } = await import('effect');
 describe('ProjectList', () => {
     const mockOnSelectProject = vi.fn();
     const mockOnDismissError = vi.fn();
@@ -66,7 +76,7 @@ describe('ProjectList', () => {
     ];
     beforeEach(() => {
         vi.clearAllMocks();
-        vi.mocked(projectManager.instance.discoverProjects).mockResolvedValue(mockProjects);
+        vi.mocked(projectManager.instance.discoverProjectsEffect).mockReturnValue(Effect.succeed(mockProjects));
     });
     it('should render project list with correct title', () => {
         const { lastFrame } = render(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
@@ -74,8 +84,8 @@ describe('ProjectList', () => {
         expect(lastFrame()).toContain('Select a project:');
     });
     it('should display loading state initially', () => {
-        // Create a promise that never resolves to keep loading state
-        vi.mocked(projectManager.instance.discoverProjects).mockReturnValue(new Promise(() => { }));
+        // Create an Effect that never completes to keep loading state
+        vi.mocked(projectManager.instance.discoverProjectsEffect).mockReturnValue(Effect.async(() => { }));
         const { lastFrame } = render(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
         expect(lastFrame()).toContain('Loading projects...');
     });
@@ -164,13 +174,17 @@ describe('ProjectList', () => {
         expect(frame).toContain('Refresh');
     });
     it('should show empty state when no projects found', async () => {
-        vi.mocked(projectManager.instance.discoverProjects).mockResolvedValue([]);
+        vi.mocked(projectManager.instance.discoverProjectsEffect).mockReturnValue(Effect.succeed([]));
         const { lastFrame, rerender } = render(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+        // Wait for loading to finish
+        await new Promise(resolve => setTimeout(resolve, 100));
+        // Force rerender
+        rerender(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
         // Wait for projects to load
         await vi.waitFor(() => {
-            rerender(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
-            return lastFrame()?.includes('No git repositories found') ?? false;
-        });
+            const frame = lastFrame();
+            return frame && !frame.includes('Loading projects...');
+        }, { timeout: 2000 });
         expect(lastFrame()).toContain('No git repositories found in /projects');
     });
     it('should display error message when error prop is provided', () => {
@@ -498,4 +512,87 @@ describe('ProjectList', () => {
             process.stdin.setRawMode = originalSetRawMode;
         });
     });
+    describe('Effect-based Project Discovery Error Handling', () => {
+        it('should handle FileSystemError from discoverProjectsEffect gracefully', async () => {
+            const { FileSystemError } = await import('../types/errors.js');
+            // Mock discoverProjectsEffect to return a failed Effect with FileSystemError
+            const fileSystemError = new FileSystemError({
+                operation: 'read',
+                path: '/projects',
+                cause: 'Directory not accessible',
+            });
+            vi.mocked(projectManager.instance.discoverProjectsEffect).mockReturnValue(Effect.fail(fileSystemError));
+            const { lastFrame, rerender } = render(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+            // Wait for loading to finish
+            await new Promise(resolve => setTimeout(resolve, 100));
+            // Force rerender
+            rerender(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+            // Wait for projects to attempt loading
+            await vi.waitFor(() => {
+                const frame = lastFrame();
+                return frame && !frame.includes('Loading projects...');
+            }, { timeout: 2000 });
+            // Should display error message with FileSystemError details
+            const frame = lastFrame();
+            expect(frame).toContain('Error:');
+        });
+        it.skip('should handle GitError from project validation failures', async () => {
+            const { GitError } = await import('../types/errors.js');
+            // Mock discoverProjectsEffect to return a failed Effect with GitError
+            const gitError = new GitError({
+                command: 'git rev-parse --show-toplevel',
+                exitCode: 128,
+                stderr: 'Not a git repository',
+            });
+            vi.mocked(projectManager.instance.discoverProjectsEffect).mockReturnValue(
+            // @ts-expect-error - Test uses wrong error type (should be FileSystemError)
+            Effect.fail(gitError));
+            const { lastFrame, rerender } = render(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+            // Wait for projects to attempt loading
+            await vi.waitFor(() => {
+                rerender(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+                return !lastFrame()?.includes('Loading projects...');
+            });
+            // Should display error message
+            const frame = lastFrame();
+            expect(frame).toContain('Error:');
+        });
+        it('should implement cancellation flag for cleanup on unmount', async () => {
+            vi.mocked(projectManager.instance.discoverProjectsEffect).mockReturnValue(Effect.async(emit => {
+                const timeout = setTimeout(() => {
+                    emit(Effect.succeed(mockProjects));
+                }, 500);
+                return Effect.sync(() => clearTimeout(timeout));
+            }));
+            const { unmount, lastFrame } = render(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+            // Wait a bit to ensure promise is pending
+            await new Promise(resolve => setTimeout(resolve, 100));
+            // Component should still be loading
+            expect(lastFrame()).toContain('Loading projects...');
+            // Unmount before promise resolves
+            unmount();
+            // Wait for promise to potentially resolve
+            await new Promise(resolve => setTimeout(resolve, 500));
+            // Component is unmounted, no state updates should occur
+            // This test verifies the cancellation flag prevents state updates after unmount
+        });
+        it('should successfully load projects using Effect execution', async () => {
+            vi.mocked(projectManager.instance.discoverProjectsEffect).mockReturnValue(Effect.succeed(mockProjects));
+            const { lastFrame, rerender } = render(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+            // Wait for loading to finish
+            await new Promise(resolve => setTimeout(resolve, 100));
+            // Force rerender
+            rerender(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
+            // Wait for projects to load
+            await vi.waitFor(() => {
+                const frame = lastFrame();
+                return frame && frame.includes('project1');
+            }, { timeout: 2000 });
+            // Should display loaded projects
+            const frame = lastFrame();
+            expect(frame).toContain('0 ❯ project1');
+            expect(frame).toContain('1 ❯ project2');
+            expect(frame).toContain('2 ❯ project3');
+        });
+    });
 });

package/dist/components/RemoteBranchSelector.test.js

@@ -62,7 +62,9 @@ describe('RemoteBranchSelector Component', () => {
         const { lastFrame } = render(React.createElement(RemoteBranchSelector, { branchName: mockBranchName, matches: mockMatches, onSelect: onSelect, onCancel: onCancel }));
         const output = lastFrame();
         expect(output).toContain('⚠️ Ambiguous Branch Reference');
-        expect(output).toContain(`Branch 'feature/awesome-feature' exists in multiple remotes`);
+        // The component renders the branch name and checks for the message
+        expect(output).toContain('feature/awesome-feature');
+        expect(output).toContain('exists in multiple remotes.');
     });
     it('should render all remote branch options', () => {
         const { lastFrame } = render(React.createElement(RemoteBranchSelector, { branchName: mockBranchName, matches: mockMatches, onSelect: onSelect, onCancel: onCancel }));

package/dist/hooks/useGitStatus.d.ts

@@ -1,2 +1,13 @@
 import { Worktree } from '../types/index.js';
+/**
+ * Custom hook for polling git status of worktrees with Effect-based execution
+ *
+ * Fetches git status for each worktree at regular intervals using Effect.runPromiseExit
+ * and updates worktree state with results. Handles cancellation via AbortController.
+ *
+ * @param worktrees - Array of worktrees to monitor
+ * @param defaultBranch - Default branch for comparisons (null disables polling)
+ * @param updateInterval - Polling interval in milliseconds (default: 5000)
+ * @returns Array of worktrees with updated gitStatus and gitStatusError fields
+ */
 export declare function useGitStatus(worktrees: Worktree[], defaultBranch: string | null, updateInterval?: number): Worktree[];

package/dist/hooks/useGitStatus.js

@@ -1,5 +1,17 @@
 import { useEffect, useState } from 'react';
+import { Effect, Exit, Cause, Option } from 'effect';
 import { getGitStatusLimited } from '../utils/gitStatus.js';
+/**
+ * Custom hook for polling git status of worktrees with Effect-based execution
+ *
+ * Fetches git status for each worktree at regular intervals using Effect.runPromiseExit
+ * and updates worktree state with results. Handles cancellation via AbortController.
+ *
+ * @param worktrees - Array of worktrees to monitor
+ * @param defaultBranch - Default branch for comparisons (null disables polling)
+ * @param updateInterval - Polling interval in milliseconds (default: 5000)
+ * @returns Array of worktrees with updated gitStatus and gitStatusError fields
+ */
 export function useGitStatus(worktrees, defaultBranch, updateInterval = 5000) {
     const [worktreesWithStatus, setWorktreesWithStatus] = useState(worktrees);
     useEffect(() => {
@@ -10,22 +22,21 @@ export function useGitStatus(worktrees, defaultBranch, updateInterval = 5000) {
         const activeRequests = new Map();
         let isCleanedUp = false;
         const fetchStatus = async (worktree, abortController) => {
-            try {
-                const result = await getGitStatusLimited(worktree.path, abortController.signal);
-                if (result.data || result.error) {
-                    setWorktreesWithStatus(prev => prev.map(wt => wt.path === worktree.path
-                        ? { ...wt, gitStatus: result.data, gitStatusError: result.error }
-                        : wt));
-                }
-            }
-            catch {
-                // Ignore errors - the fetch failed or was aborted
-            }
+            // Execute the Effect to get git status with cancellation support
+            const exit = await Effect.runPromiseExit(getGitStatusLimited(worktree.path), {
+                signal: abortController.signal,
+            });
+            // Update worktree state based on exit result
+            handleStatusExit(exit, worktree.path, setWorktreesWithStatus);
         };
         const scheduleUpdate = (worktree) => {
             const abortController = new AbortController();
             activeRequests.set(worktree.path, abortController);
-            fetchStatus(worktree, abortController).finally(() => {
+            fetchStatus(worktree, abortController)
+                .catch(() => {
+                // Ignore errors - the fetch failed or was aborted
+            })
+                .finally(() => {
                 const isActive = () => !isCleanedUp && !abortController.signal.aborted;
                 if (isActive()) {
                     const timeout = setTimeout(() => {
@@ -50,3 +61,50 @@ export function useGitStatus(worktrees, defaultBranch, updateInterval = 5000) {
     }, [worktrees, defaultBranch, updateInterval]);
     return worktreesWithStatus;
 }
+/**
+ * Handle the Exit result from Effect.runPromiseExit and update worktree state
+ *
+ * Uses pattern matching on Exit to distinguish between success, failure, and interruption.
+ * Success updates gitStatus, failure updates gitStatusError, interruption is ignored.
+ *
+ * @param exit - Exit result from Effect execution
+ * @param worktreePath - Path of the worktree being updated
+ * @param setWorktreesWithStatus - State setter function
+ */
+function handleStatusExit(exit, worktreePath, setWorktreesWithStatus) {
+    if (Exit.isSuccess(exit)) {
+        // Success: update gitStatus and clear error
+        const gitStatus = exit.value;
+        setWorktreesWithStatus(prev => prev.map(wt => wt.path === worktreePath
+            ? { ...wt, gitStatus, gitStatusError: undefined }
+            : wt));
+    }
+    else if (Exit.isFailure(exit)) {
+        // Failure: extract error and update gitStatusError
+        const failure = Cause.failureOption(exit.cause);
+        if (Option.isSome(failure)) {
+            const gitError = failure.value;
+            const errorMessage = formatGitError(gitError);
+            setWorktreesWithStatus(prev => prev.map(wt => wt.path === worktreePath
+                ? { ...wt, gitStatus: undefined, gitStatusError: errorMessage }
+                : wt));
+        }
+    }
+    // Interruption: no state update - the request was cancelled
+}
+/**
+ * Format GitError into a user-friendly error message
+ *
+ * @param error - GitError from failed git operation
+ * @returns Formatted error message string
+ */
+function formatGitError(error) {
+    const exitCode = Number.isFinite(error.exitCode) ? error.exitCode : -1;
+    const details = [error.stderr, error.stdout]
+        .filter(part => typeof part === 'string' && part.trim().length > 0)
+        .map(part => part.trim());
+    const detail = details[0] ?? '';
+    return detail
+        ? `git command "${error.command}" failed (exit code ${exitCode}): ${detail}`
+        : `git command "${error.command}" failed (exit code ${exitCode})`;
+}

package/dist/hooks/useGitStatus.test.js

@@ -2,8 +2,10 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import React from 'react';
 import { render, cleanup } from 'ink-testing-library';
 import { Text } from 'ink';
+import { Effect, Exit } from 'effect';
 import { useGitStatus } from './useGitStatus.js';
 import { getGitStatusLimited } from '../utils/gitStatus.js';
+import { GitError } from '../types/errors.js';
 // Mock the gitStatus module
 vi.mock('../utils/gitStatus.js', () => ({
     getGitStatusLimited: vi.fn(),
@@ -37,11 +39,11 @@ describe('useGitStatus', () => {
         const gitStatus1 = createGitStatus(5, 3);
         const gitStatus2 = createGitStatus(2, 1);
         let hookResult = [];
-        mockGetGitStatus.mockImplementation(async (path) => {
+        mockGetGitStatus.mockImplementation(path => {
             if (path === '/path1') {
-                return { success: true, data: gitStatus1 };
+                return Effect.succeed(gitStatus1);
             }
-            return { success: true, data: gitStatus2 };
+            return Effect.succeed(gitStatus2);
         });
         const TestComponent = () => {
             hookResult = useGitStatus(worktrees, 'main', 100);
@@ -85,10 +87,12 @@ describe('useGitStatus', () => {
     });
     it('should continue polling after errors', async () => {
         const worktrees = [createWorktree('/path1')];
-        mockGetGitStatus.mockResolvedValue({
-            success: false,
-            error: 'Git error',
+        const gitError = new GitError({
+            command: 'git status',
+            exitCode: 128,
+            stderr: 'Git error',
         });
+        mockGetGitStatus.mockReturnValue(Effect.fail(gitError));
         const TestComponent = () => {
             useGitStatus(worktrees, 'main', 100);
             return React.createElement(Text, null, 'test');
@@ -106,17 +110,17 @@ describe('useGitStatus', () => {
         await vi.advanceTimersByTimeAsync(100);
         expect(mockGetGitStatus).toHaveBeenCalledTimes(2);
         // All calls should have been made despite continuous errors
-        expect(mockGetGitStatus).toHaveBeenCalledWith('/path1', expect.any(AbortSignal));
+        expect(mockGetGitStatus).toHaveBeenCalledWith('/path1');
     });
     it('should handle slow git operations that exceed update interval', async () => {
         const worktrees = [createWorktree('/path1')];
         let fetchCount = 0;
-        let resolveFetch = null;
-        mockGetGitStatus.mockImplementation(async () => {
+        let resolveEffect = null;
+        mockGetGitStatus.mockImplementation(() => {
             fetchCount++;
-            // Create a promise that we can resolve manually
-            return new Promise(resolve => {
-                resolveFetch = resolve;
+            // Create an Effect that we can resolve manually
+            return Effect.async(resume => {
+                resolveEffect = resume;
             });
         });
         const TestComponent = () => {
@@ -133,7 +137,7 @@ describe('useGitStatus', () => {
         // Should not have started a second fetch yet
         expect(mockGetGitStatus).toHaveBeenCalledTimes(1);
         // Complete the first fetch
-        resolveFetch({ success: true, data: createGitStatus(1, 0) });
+        resolveEffect(Exit.succeed(createGitStatus(1, 0)));
         // Wait for the promise to resolve
         await vi.waitFor(() => {
             expect(fetchCount).toBe(1);
@@ -147,15 +151,16 @@ describe('useGitStatus', () => {
     });
     it('should properly cleanup resources when worktrees change', async () => {
         let activeRequests = 0;
-        const abortedSignals = [];
-        mockGetGitStatus.mockImplementation(async (path, signal) => {
+        const interruptedPaths = [];
+        mockGetGitStatus.mockImplementation(path => {
             activeRequests++;
-            signal.addEventListener('abort', () => {
-                activeRequests--;
-                abortedSignals.push(signal);
+            // Create an Effect that never completes but handles interruption
+            return Effect.async(_resume => {
+                return Effect.sync(() => {
+                    activeRequests--;
+                    interruptedPaths.push(path);
+                });
             });
-            // Simulate ongoing request
-            return new Promise(() => { });
         });
         const TestComponent = ({ worktrees }) => {
             useGitStatus(worktrees, 'main', 100);
@@ -177,10 +182,12 @@ describe('useGitStatus', () => {
         rerender(React.createElement(TestComponent, { worktrees: newWorktrees }));
         // Wait for cleanup and new requests
         await vi.waitFor(() => {
-            expect(abortedSignals).toHaveLength(3);
+            expect(interruptedPaths).toHaveLength(3);
             expect(activeRequests).toBe(2);
         });
-        // Verify all old signals were aborted
-        expect(abortedSignals.every(signal => signal.aborted)).toBe(true);
+        // Verify all old paths were interrupted
+        expect(interruptedPaths).toContain('/path1');
+        expect(interruptedPaths).toContain('/path2');
+        expect(interruptedPaths).toContain('/path3');
     });
 });

package/dist/services/configurationManager.d.ts

@@ -1,4 +1,6 @@
+import { Effect, Either } from 'effect';
 import { ConfigurationData, StatusHookConfig, WorktreeHookConfig, ShortcutConfig, WorktreeConfig, CommandConfig, CommandPreset, CommandPresetsConfig } from '../types/index.js';
+import { FileSystemError, ConfigError, ValidationError } from '../types/errors.js';
 export declare class ConfigurationManager {
     private configPath;
     private legacyShortcutsPath;
@@ -30,5 +32,78 @@ export declare class ConfigurationManager {
     setDefaultPreset(id: string): void;
     getSelectPresetOnStart(): boolean;
     setSelectPresetOnStart(enabled: boolean): void;
+    /**
+     * Load configuration from file with Effect-based error handling
+     *
+     * @returns {Effect.Effect<ConfigurationData, FileSystemError | ConfigError, never>} Configuration data on success, errors on failure
+     *
+     * @example
+     * ```typescript
+     * const result = await Effect.runPromise(
+     *   configManager.loadConfigEffect()
+     * );
+     * ```
+     */
+    loadConfigEffect(): Effect.Effect<ConfigurationData, FileSystemError | ConfigError, never>;
+    /**
+     * Save configuration to file with Effect-based error handling
+     *
+     * @returns {Effect.Effect<void, FileSystemError, never>} Void on success, FileSystemError on write failure
+     *
+     * @example
+     * ```typescript
+     * await Effect.runPromise(
+     *   configManager.saveConfigEffect(config)
+     * );
+     * ```
+     */
+    saveConfigEffect(config: ConfigurationData): Effect.Effect<void, FileSystemError, never>;
+    /**
+     * Validate configuration structure
+     * Synchronous validation using Either
+     */
+    validateConfig(config: unknown): Either.Either<ValidationError, ConfigurationData>;
+    /**
+     * Get preset by ID with Either-based error handling
+     * Synchronous lookup using Either
+     */
+    getPresetByIdEffect(id: string): Either.Either<ValidationError, CommandPreset>;
+    /**
+     * Set shortcuts with Effect-based error handling
+     *
+     * @returns {Effect.Effect<void, FileSystemError, never>} Void on success, FileSystemError on save failure
+     *
+     * @example
+     * ```typescript
+     * await Effect.runPromise(
+     *   configManager.setShortcutsEffect(shortcuts)
+     * );
+     * ```
+     */
+    setShortcutsEffect(shortcuts: ShortcutConfig): Effect.Effect<void, FileSystemError, never>;
+    /**
+     * Set command presets with Effect-based error handling
+     */
+    setCommandPresetsEffect(presets: CommandPresetsConfig): Effect.Effect<void, FileSystemError, never>;
+    /**
+     * Add or update preset with Effect-based error handling
+     */
+    addPresetEffect(preset: CommandPreset): Effect.Effect<void, FileSystemError, never>;
+    /**
+     * Delete preset with Effect-based error handling
+     */
+    deletePresetEffect(id: string): Effect.Effect<void, ValidationError | FileSystemError, never>;
+    /**
+     * Set default preset with Effect-based error handling
+     */
+    setDefaultPresetEffect(id: string): Effect.Effect<void, ValidationError | FileSystemError, never>;
+    /**
+     * Apply default values to configuration
+     */
+    private applyDefaults;
+    /**
+     * Synchronous legacy shortcuts migration helper
+     */
+    private migrateLegacyShortcutsSync;
 }
 export declare const configurationManager: ConfigurationManager;

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

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