ccmanager 2.8.0 → 2.9.0

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');
+            }
+        });
+    });
+});

package/dist/services/configurationManager.js

@@ -1,7 +1,9 @@
 import { homedir } from 'os';
 import { join } from 'path';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { Effect, Either } from 'effect';
 import { DEFAULT_SHORTCUTS, } from '../types/index.js';
+import { FileSystemError, ConfigError, ValidationError, } from '../types/errors.js';
 export class ConfigurationManager {
     constructor() {
         Object.defineProperty(this, "configPath", {
@@ -268,5 +270,249 @@ export class ConfigurationManager {
         presets.selectPresetOnStart = enabled;
         this.setCommandPresets(presets);
     }
+    // Effect-based methods for type-safe error handling
+    /**
+     * 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() {
+        return Effect.try({
+            try: () => {
+                // Try to load the new config file
+                if (existsSync(this.configPath)) {
+                    const configData = readFileSync(this.configPath, 'utf-8');
+                    const parsedConfig = JSON.parse(configData);
+                    return this.applyDefaults(parsedConfig);
+                }
+                else {
+                    // If new config doesn't exist, check for legacy shortcuts.json
+                    const migratedConfig = this.migrateLegacyShortcutsSync();
+                    return this.applyDefaults(migratedConfig || {});
+                }
+            },
+            catch: (error) => {
+                // Determine error type
+                if (error instanceof SyntaxError) {
+                    return new ConfigError({
+                        configPath: this.configPath,
+                        reason: 'parse',
+                        details: String(error),
+                    });
+                }
+                return new FileSystemError({
+                    operation: 'read',
+                    path: this.configPath,
+                    cause: String(error),
+                });
+            },
+        });
+    }
+    /**
+     * 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) {
+        return Effect.try({
+            try: () => {
+                this.config = config;
+                writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+            },
+            catch: (error) => {
+                return new FileSystemError({
+                    operation: 'write',
+                    path: this.configPath,
+                    cause: String(error),
+                });
+            },
+        });
+    }
+    /**
+     * Validate configuration structure
+     * Synchronous validation using Either
+     */
+    validateConfig(config) {
+        if (!config || typeof config !== 'object') {
+            return Either.left(new ValidationError({
+                field: 'config',
+                constraint: 'must be a valid configuration object',
+                receivedValue: config,
+            }));
+        }
+        // Validate shortcuts field if present
+        const configObj = config;
+        if (configObj['shortcuts'] !== undefined &&
+            (typeof configObj['shortcuts'] !== 'object' ||
+                configObj['shortcuts'] === null)) {
+            return Either.left(new ValidationError({
+                field: 'config',
+                constraint: 'shortcuts must be a valid object',
+                receivedValue: config,
+            }));
+        }
+        // Additional validation could go here
+        return Either.right(config);
+    }
+    /**
+     * Get preset by ID with Either-based error handling
+     * Synchronous lookup using Either
+     */
+    getPresetByIdEffect(id) {
+        const presets = this.getCommandPresets();
+        const preset = presets.presets.find(p => p.id === id);
+        if (!preset) {
+            return Either.left(new ValidationError({
+                field: 'presetId',
+                constraint: 'Preset not found',
+                receivedValue: id,
+            }));
+        }
+        return Either.right(preset);
+    }
+    /**
+     * 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) {
+        this.config.shortcuts = shortcuts;
+        return this.saveConfigEffect(this.config);
+    }
+    /**
+     * Set command presets with Effect-based error handling
+     */
+    setCommandPresetsEffect(presets) {
+        this.config.commandPresets = presets;
+        return this.saveConfigEffect(this.config);
+    }
+    /**
+     * Add or update preset with Effect-based error handling
+     */
+    addPresetEffect(preset) {
+        const presets = this.getCommandPresets();
+        // Replace if exists, otherwise add
+        const existingIndex = presets.presets.findIndex(p => p.id === preset.id);
+        if (existingIndex >= 0) {
+            presets.presets[existingIndex] = preset;
+        }
+        else {
+            presets.presets.push(preset);
+        }
+        return this.setCommandPresetsEffect(presets);
+    }
+    /**
+     * Delete preset with Effect-based error handling
+     */
+    deletePresetEffect(id) {
+        const presets = this.getCommandPresets();
+        // Don't delete if it's the last preset
+        if (presets.presets.length <= 1) {
+            return Effect.fail(new ValidationError({
+                field: 'presetId',
+                constraint: 'Cannot delete last preset',
+                receivedValue: id,
+            }));
+        }
+        // Remove the preset
+        presets.presets = presets.presets.filter(p => p.id !== id);
+        // Update default if needed
+        if (presets.defaultPresetId === id && presets.presets.length > 0) {
+            presets.defaultPresetId = presets.presets[0].id;
+        }
+        return this.setCommandPresetsEffect(presets);
+    }
+    /**
+     * Set default preset with Effect-based error handling
+     */
+    setDefaultPresetEffect(id) {
+        const presets = this.getCommandPresets();
+        // Only update if preset exists
+        if (!presets.presets.some(p => p.id === id)) {
+            return Effect.fail(new ValidationError({
+                field: 'presetId',
+                constraint: 'Preset not found',
+                receivedValue: id,
+            }));
+        }
+        presets.defaultPresetId = id;
+        return this.setCommandPresetsEffect(presets);
+    }
+    // Helper methods
+    /**
+     * Apply default values to configuration
+     */
+    applyDefaults(config) {
+        // Ensure default values
+        if (!config.shortcuts) {
+            config.shortcuts = DEFAULT_SHORTCUTS;
+        }
+        if (!config.statusHooks) {
+            config.statusHooks = {};
+        }
+        if (!config.worktreeHooks) {
+            config.worktreeHooks = {};
+        }
+        if (!config.worktree) {
+            config.worktree = {
+                autoDirectory: false,
+                copySessionData: true,
+            };
+        }
+        if (!Object.prototype.hasOwnProperty.call(config.worktree, 'copySessionData')) {
+            config.worktree.copySessionData = true;
+        }
+        if (!config.command) {
+            config.command = {
+                command: 'claude',
+            };
+        }
+        return config;
+    }
+    /**
+     * Synchronous legacy shortcuts migration helper
+     */
+    migrateLegacyShortcutsSync() {
+        if (existsSync(this.legacyShortcutsPath)) {
+            try {
+                const shortcutsData = readFileSync(this.legacyShortcutsPath, 'utf-8');
+                const shortcuts = JSON.parse(shortcutsData);
+                // Validate that it's a valid shortcuts config
+                if (shortcuts && typeof shortcuts === 'object') {
+                    const config = { shortcuts };
+                    // Save to new config format
+                    this.config = config;
+                    writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+                    console.log('Migrated shortcuts from legacy shortcuts.json to config.json');
+                    return config;
+                }
+            }
+            catch (error) {
+                console.error('Failed to migrate legacy shortcuts:', error);
+            }
+        }
+        return null;
+    }
 }
 export const configurationManager = new ConfigurationManager();

package/dist/services/globalSessionOrchestrator.test.js

@@ -35,14 +35,6 @@ vi.mock('./sessionManager.js', () => {
         emit() {
             // Mock implementation
         }
-        async createSessionWithPreset(_worktreePath, _presetId) {
-            // Mock implementation
-            return {};
-        }
-        async createSessionWithDevcontainer(_worktreePath, _config, _presetId) {
-            // Mock implementation
-            return {};
-        }
     }
     return { SessionManager: MockSessionManager };
 });