ccmanager 2.8.0 → 2.9.1

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 {};

package/dist/services/configurationManager.effect.test.js

@@ -0,0 +1,407 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { Effect, Either } from 'effect';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { ConfigurationManager } from './configurationManager.js';
+// Mock fs module
+vi.mock('fs', () => ({
+    existsSync: vi.fn(),
+    mkdirSync: vi.fn(),
+    readFileSync: vi.fn(),
+    writeFileSync: vi.fn(),
+}));
+// Mock os module
+vi.mock('os', () => ({
+    homedir: vi.fn(() => '/home/test'),
+}));
+describe('ConfigurationManager - Effect-based operations', () => {
+    let configManager;
+    let mockConfigData;
+    beforeEach(() => {
+        // Reset all mocks
+        vi.clearAllMocks();
+        // Default mock config data
+        mockConfigData = {
+            shortcuts: {
+                returnToMenu: { ctrl: true, key: 'e' },
+                cancel: { key: 'escape' },
+            },
+            command: {
+                command: 'claude',
+                args: ['--existing'],
+            },
+        };
+        // Mock file system operations
+        existsSync.mockImplementation((path) => {
+            return path.includes('config.json');
+        });
+        readFileSync.mockImplementation(() => {
+            return JSON.stringify(mockConfigData);
+        });
+        mkdirSync.mockImplementation(() => { });
+        writeFileSync.mockImplementation(() => { });
+        // Create new instance for each test
+        configManager = new ConfigurationManager();
+    });
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+    describe('loadConfigEffect', () => {
+        it('should return Effect with ConfigurationData on success', async () => {
+            const result = await Effect.runPromise(configManager.loadConfigEffect());
+            expect(result).toBeDefined();
+            expect(result.shortcuts).toBeDefined();
+            expect(result.command).toBeDefined();
+        });
+        it('should fail with FileSystemError when file read fails', async () => {
+            readFileSync.mockImplementation(() => {
+                throw new Error('EACCES: permission denied');
+            });
+            configManager = new ConfigurationManager();
+            const result = await Effect.runPromise(Effect.either(configManager.loadConfigEffect()));
+            expect(Either.isLeft(result)).toBe(true);
+            if (Either.isLeft(result)) {
+                expect(result.left._tag).toBe('FileSystemError');
+                expect(result.left.operation).toBe('read');
+                expect(result.left.cause).toContain('permission denied');
+            }
+        });
+        it('should fail with ConfigError when JSON parsing fails', async () => {
+            readFileSync.mockImplementation(() => {
+                return 'invalid json{';
+            });
+            configManager = new ConfigurationManager();
+            const result = await Effect.runPromise(Effect.either(configManager.loadConfigEffect()));
+            expect(Either.isLeft(result)).toBe(true);
+            if (Either.isLeft(result)) {
+                expect(result.left._tag).toBe('ConfigError');
+                expect(result.left.reason).toBe('parse');
+            }
+        });
+        it('should migrate legacy shortcuts and return success', async () => {
+            existsSync.mockImplementation((path) => {
+                if (path.includes('shortcuts.json'))
+                    return true;
+                if (path.includes('config.json'))
+                    return false;
+                return true;
+            });
+            const legacyShortcuts = {
+                returnToMenu: { ctrl: true, key: 'b' },
+            };
+            readFileSync.mockImplementation((path) => {
+                if (path.includes('shortcuts.json')) {
+                    return JSON.stringify(legacyShortcuts);
+                }
+                return '{}';
+            });
+            configManager = new ConfigurationManager();
+            const result = await Effect.runPromise(configManager.loadConfigEffect());
+            expect(result.shortcuts).toEqual(legacyShortcuts);
+            expect(writeFileSync).toHaveBeenCalled();
+        });
+    });
+    describe('saveConfigEffect', () => {
+        it('should return Effect<void> on successful save', async () => {
+            const newConfig = {
+                shortcuts: {
+                    returnToMenu: { ctrl: true, key: 'z' },
+                    cancel: { key: 'escape' },
+                },
+            };
+            await Effect.runPromise(configManager.saveConfigEffect(newConfig));
+            expect(writeFileSync).toHaveBeenCalledWith(expect.stringContaining('config.json'), expect.any(String));
+        });
+        it('should fail with FileSystemError when file write fails', async () => {
+            writeFileSync.mockImplementation(() => {
+                throw new Error('ENOSPC: no space left on device');
+            });
+            const newConfig = {
+                shortcuts: {
+                    returnToMenu: { ctrl: true, key: 'z' },
+                    cancel: { key: 'escape' },
+                },
+            };
+            const result = await Effect.runPromise(Effect.either(configManager.saveConfigEffect(newConfig)));
+            expect(Either.isLeft(result)).toBe(true);
+            if (Either.isLeft(result)) {
+                expect(result.left._tag).toBe('FileSystemError');
+                expect(result.left.operation).toBe('write');
+                expect(result.left.cause).toContain('no space left on device');
+            }
+        });
+    });
+    describe('validateConfig', () => {
+        it('should return Right with valid ConfigurationData', () => {
+            const validConfig = {
+                shortcuts: {
+                    returnToMenu: { ctrl: true, key: 'e' },
+                    cancel: { key: 'escape' },
+                },
+            };
+            const result = configManager.validateConfig(validConfig);
+            expect(Either.isRight(result)).toBe(true);
+            if (Either.isRight(result)) {
+                expect(result.right).toEqual(validConfig);
+            }
+        });
+        it('should return Left with ValidationError for invalid config', () => {
+            const invalidConfig = {
+                shortcuts: 'not an object',
+            };
+            const result = configManager.validateConfig(invalidConfig);
+            expect(Either.isLeft(result)).toBe(true);
+            if (Either.isLeft(result)) {
+                const error = result.left;
+                expect(error._tag).toBe('ValidationError');
+                expect(error.field).toBe('config');
+            }
+        });
+        it('should return Left for null config', () => {
+            const result = configManager.validateConfig(null);
+            expect(Either.isLeft(result)).toBe(true);
+            if (Either.isLeft(result)) {
+                const error = result.left;
+                expect(error._tag).toBe('ValidationError');
+            }
+        });
+    });
+    describe('getPresetByIdEffect', () => {
+        it('should return Right with preset when found', () => {
+            mockConfigData.commandPresets = {
+                presets: [
+                    { id: '1', name: 'Main', command: 'claude' },
+                    { id: '2', name: 'Custom', command: 'claude', args: ['--custom'] },
+                ],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            const result = configManager.getPresetByIdEffect('2');
+            expect(Either.isRight(result)).toBe(true);
+            if (Either.isRight(result)) {
+                expect(result.right).toEqual({
+                    id: '2',
+                    name: 'Custom',
+                    command: 'claude',
+                    args: ['--custom'],
+                });
+            }
+        });
+        it('should return Left with ValidationError when preset not found', () => {
+            mockConfigData.commandPresets = {
+                presets: [{ id: '1', name: 'Main', command: 'claude' }],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            const result = configManager.getPresetByIdEffect('999');
+            expect(Either.isLeft(result)).toBe(true);
+            if (Either.isLeft(result)) {
+                const error = result.left;
+                expect(error._tag).toBe('ValidationError');
+                expect(error.field).toBe('presetId');
+                expect(error.receivedValue).toBe('999');
+            }
+        });
+        it('should include constraint in ValidationError', () => {
+            mockConfigData.commandPresets = {
+                presets: [{ id: '1', name: 'Main', command: 'claude' }],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            const result = configManager.getPresetByIdEffect('invalid-id');
+            expect(Either.isLeft(result)).toBe(true);
+            if (Either.isLeft(result)) {
+                const error = result.left;
+                expect(error.constraint).toContain('not found');
+            }
+        });
+    });
+    describe('setShortcutsEffect', () => {
+        it('should return Effect<void> on successful update', async () => {
+            const newShortcuts = {
+                returnToMenu: { ctrl: true, key: 'z' },
+                cancel: { key: 'escape' },
+            };
+            await Effect.runPromise(configManager.setShortcutsEffect(newShortcuts));
+            expect(writeFileSync).toHaveBeenCalled();
+        });
+        it('should fail with FileSystemError when save fails', async () => {
+            writeFileSync.mockImplementation(() => {
+                throw new Error('Write failed');
+            });
+            const newShortcuts = {
+                returnToMenu: { ctrl: true, key: 'z' },
+                cancel: { key: 'escape' },
+            };
+            const result = await Effect.runPromise(Effect.either(configManager.setShortcutsEffect(newShortcuts)));
+            expect(Either.isLeft(result)).toBe(true);
+            if (Either.isLeft(result)) {
+                expect(result.left._tag).toBe('FileSystemError');
+            }
+        });
+    });
+    describe('setCommandPresetsEffect', () => {
+        it('should return Effect<void> on successful update', async () => {
+            const newPresets = {
+                presets: [
+                    { id: '1', name: 'Main', command: 'claude' },
+                    { id: '2', name: 'Custom', command: 'claude', args: ['--custom'] },
+                ],
+                defaultPresetId: '2',
+            };
+            await Effect.runPromise(configManager.setCommandPresetsEffect(newPresets));
+            expect(writeFileSync).toHaveBeenCalled();
+        });
+        it('should fail with FileSystemError when save fails', async () => {
+            writeFileSync.mockImplementation(() => {
+                throw new Error('Disk full');
+            });
+            const newPresets = {
+                presets: [{ id: '1', name: 'Main', command: 'claude' }],
+                defaultPresetId: '1',
+            };
+            const result = await Effect.runPromise(Effect.either(configManager.setCommandPresetsEffect(newPresets)));
+            expect(Either.isLeft(result)).toBe(true);
+            if (Either.isLeft(result)) {
+                expect(result.left._tag).toBe('FileSystemError');
+            }
+        });
+    });
+    describe('addPresetEffect', () => {
+        it('should add new preset and return Effect<void>', async () => {
+            mockConfigData.commandPresets = {
+                presets: [{ id: '1', name: 'Main', command: 'claude' }],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            const newPreset = {
+                id: '2',
+                name: 'New',
+                command: 'claude',
+                args: ['--new'],
+            };
+            await Effect.runPromise(configManager.addPresetEffect(newPreset));
+            expect(writeFileSync).toHaveBeenCalled();
+        });
+        it('should replace existing preset with same id', async () => {
+            mockConfigData.commandPresets = {
+                presets: [{ id: '1', name: 'Main', command: 'claude' }],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            const updatedPreset = {
+                id: '1',
+                name: 'Updated',
+                command: 'claude',
+                args: ['--updated'],
+            };
+            await Effect.runPromise(configManager.addPresetEffect(updatedPreset));
+            expect(writeFileSync).toHaveBeenCalled();
+        });
+        it('should fail with FileSystemError when save fails', async () => {
+            writeFileSync.mockImplementation(() => {
+                throw new Error('Save failed');
+            });
+            const newPreset = {
+                id: '2',
+                name: 'New',
+                command: 'claude',
+            };
+            const result = await Effect.runPromise(Effect.either(configManager.addPresetEffect(newPreset)));
+            expect(Either.isLeft(result)).toBe(true);
+            if (Either.isLeft(result)) {
+                expect(result.left._tag).toBe('FileSystemError');
+            }
+        });
+    });
+    describe('deletePresetEffect', () => {
+        it('should delete preset and return Effect<void>', async () => {
+            mockConfigData.commandPresets = {
+                presets: [
+                    { id: '1', name: 'Main', command: 'claude' },
+                    { id: '2', name: 'Custom', command: 'claude' },
+                ],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            await Effect.runPromise(configManager.deletePresetEffect('2'));
+            expect(writeFileSync).toHaveBeenCalled();
+        });
+        it('should fail with ValidationError when deleting last preset', async () => {
+            mockConfigData.commandPresets = {
+                presets: [{ id: '1', name: 'Main', command: 'claude' }],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            const result = await Effect.runPromise(Effect.either(configManager.deletePresetEffect('1')));
+            expect(Either.isLeft(result)).toBe(true);
+            if (Either.isLeft(result)) {
+                expect(result.left._tag).toBe('ValidationError');
+                expect(result.left.field).toBe('presetId');
+                expect(result.left.constraint).toContain('Cannot delete last preset');
+            }
+        });
+        it('should fail with FileSystemError when save fails', async () => {
+            mockConfigData.commandPresets = {
+                presets: [
+                    { id: '1', name: 'Main', command: 'claude' },
+                    { id: '2', name: 'Custom', command: 'claude' },
+                ],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            writeFileSync.mockImplementation(() => {
+                throw new Error('Save failed');
+            });
+            const result = await Effect.runPromise(Effect.either(configManager.deletePresetEffect('2')));
+            expect(Either.isLeft(result)).toBe(true);
+            if (Either.isLeft(result)) {
+                expect(result.left._tag).toBe('FileSystemError');
+            }
+        });
+    });
+    describe('setDefaultPresetEffect', () => {
+        it('should update default preset and return Effect<void>', async () => {
+            mockConfigData.commandPresets = {
+                presets: [
+                    { id: '1', name: 'Main', command: 'claude' },
+                    { id: '2', name: 'Custom', command: 'claude' },
+                ],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            await Effect.runPromise(configManager.setDefaultPresetEffect('2'));
+            expect(writeFileSync).toHaveBeenCalled();
+        });
+        it('should fail with ValidationError when preset id does not exist', async () => {
+            mockConfigData.commandPresets = {
+                presets: [{ id: '1', name: 'Main', command: 'claude' }],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            const result = await Effect.runPromise(Effect.either(configManager.setDefaultPresetEffect('999')));
+            expect(Either.isLeft(result)).toBe(true);
+            if (Either.isLeft(result)) {
+                expect(result.left._tag).toBe('ValidationError');
+                expect(result.left.field).toBe('presetId');
+            }
+        });
+        it('should fail with FileSystemError when save fails', async () => {
+            mockConfigData.commandPresets = {
+                presets: [
+                    { id: '1', name: 'Main', command: 'claude' },
+                    { id: '2', name: 'Custom', command: 'claude' },
+                ],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            writeFileSync.mockImplementation(() => {
+                throw new Error('Save failed');
+            });
+            const result = await Effect.runPromise(Effect.either(configManager.setDefaultPresetEffect('2')));
+            expect(Either.isLeft(result)).toBe(true);
+            if (Either.isLeft(result)) {
+                expect(result.left._tag).toBe('FileSystemError');
+            }
+        });
+    });
+});