ccmanager 3.3.2 → 3.5.0

package/dist/services/{configurationManager.test.js → config/configEditor.test.js}

@@ -1,6 +1,7 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { ConfigurationManager } from './configurationManager.js';
+import { ConfigEditor } from './configEditor.js';
+import { addPreset, deletePreset, setDefaultPreset, getDefaultPreset, } from './testUtils.js';
 // Mock fs module
 vi.mock('fs', () => ({
     existsSync: vi.fn(),
@@ -12,44 +13,50 @@ vi.mock('fs', () => ({
 vi.mock('os', () => ({
     homedir: vi.fn(() => '/home/test'),
 }));
-describe('ConfigurationManager - Command Presets', () => {
-    let configManager;
+describe('ConfigEditor (global scope) - Command Presets', () => {
+    let configEditor;
     let mockConfigData;
+    let savedConfigData = null;
+    // Helper to reset saved config when modifying mockConfigData
+    const resetSavedConfig = () => {
+        savedConfigData = null;
+    };
     beforeEach(() => {
         // Reset all mocks
         vi.clearAllMocks();
+        savedConfigData = null;
         // 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);
+            // Return saved data if available, otherwise return initial mock data
+            return savedConfigData ?? JSON.stringify(mockConfigData);
         });
         mkdirSync.mockImplementation(() => { });
-        writeFileSync.mockImplementation(() => { });
-        // Create new instance for each test
-        configManager = new ConfigurationManager();
+        writeFileSync.mockImplementation((_path, data) => {
+            // Track written data so subsequent reads return it
+            savedConfigData = data;
+        });
+        // Create new instance for each test and reload to pick up mocked fs
+        configEditor = new ConfigEditor('global');
+        configEditor.reload();
     });
     afterEach(() => {
         vi.resetAllMocks();
     });
     describe('getCommandPresets', () => {
         it('should return default presets when no presets are configured', () => {
-            // Remove command config for this test
-            delete mockConfigData.command;
-            configManager = new ConfigurationManager();
-            const presets = configManager.getCommandPresets();
+            resetSavedConfig();
+            configEditor.reload();
+            const presets = configEditor.getCommandPresets();
             expect(presets).toBeDefined();
             expect(presets.presets).toHaveLength(1);
             expect(presets.presets[0]).toEqual({
@@ -67,33 +74,12 @@ describe('ConfigurationManager - Command Presets', () => {
                 ],
                 defaultPresetId: '2',
             };
-            configManager = new ConfigurationManager();
-            const presets = configManager.getCommandPresets();
+            resetSavedConfig();
+            configEditor.reload();
+            const presets = configEditor.getCommandPresets();
             expect(presets.presets).toHaveLength(2);
             expect(presets.defaultPresetId).toBe('2');
         });
-        it('should migrate legacy command config to presets on first access', () => {
-            // Config has legacy command but no presets
-            mockConfigData.command = {
-                command: 'claude',
-                args: ['--resume'],
-                fallbackArgs: ['--no-mcp'],
-            };
-            delete mockConfigData.commandPresets;
-            configManager = new ConfigurationManager();
-            const presets = configManager.getCommandPresets();
-            expect(presets.presets).toHaveLength(1);
-            expect(presets.presets[0]).toEqual({
-                id: '1',
-                name: 'Main',
-                command: 'claude',
-                args: ['--resume'],
-                fallbackArgs: ['--no-mcp'],
-            });
-            expect(presets.defaultPresetId).toBe('1');
-            // Verify that writeFileSync was called to save the migration
-            expect(writeFileSync).toHaveBeenCalled();
-        });
     });
     describe('setCommandPresets', () => {
         it('should save new presets configuration', () => {
@@ -104,7 +90,7 @@ describe('ConfigurationManager - Command Presets', () => {
                 ],
                 defaultPresetId: '2',
             };
-            configManager.setCommandPresets(newPresets);
+            configEditor.setCommandPresets(newPresets);
             expect(writeFileSync).toHaveBeenCalledWith(expect.stringContaining('config.json'), expect.stringContaining('commandPresets'));
         });
     });
@@ -117,8 +103,9 @@ describe('ConfigurationManager - Command Presets', () => {
                 ],
                 defaultPresetId: '2',
             };
-            configManager = new ConfigurationManager();
-            const defaultPreset = configManager.getDefaultPreset();
+            resetSavedConfig();
+            configEditor.reload();
+            const defaultPreset = getDefaultPreset(configEditor);
             expect(defaultPreset).toEqual({
                 id: '2',
                 name: 'Custom',
@@ -134,8 +121,9 @@ describe('ConfigurationManager - Command Presets', () => {
                 ],
                 defaultPresetId: 'invalid',
             };
-            configManager = new ConfigurationManager();
-            const defaultPreset = configManager.getDefaultPreset();
+            resetSavedConfig();
+            configEditor.reload();
+            const defaultPreset = getDefaultPreset(configEditor);
             expect(defaultPreset).toEqual({
                 id: '1',
                 name: 'Main',
@@ -143,49 +131,22 @@ describe('ConfigurationManager - Command Presets', () => {
             });
         });
     });
-    describe('getPresetById', () => {
-        it('should return preset by id', () => {
-            mockConfigData.commandPresets = {
-                presets: [
-                    { id: '1', name: 'Main', command: 'claude' },
-                    { id: '2', name: 'Custom', command: 'claude', args: ['--custom'] },
-                ],
-                defaultPresetId: '1',
-            };
-            configManager = new ConfigurationManager();
-            const preset = configManager.getPresetById('2');
-            expect(preset).toEqual({
-                id: '2',
-                name: 'Custom',
-                command: 'claude',
-                args: ['--custom'],
-            });
-        });
-        it('should return undefined for non-existent id', () => {
-            mockConfigData.commandPresets = {
-                presets: [{ id: '1', name: 'Main', command: 'claude' }],
-                defaultPresetId: '1',
-            };
-            configManager = new ConfigurationManager();
-            const preset = configManager.getPresetById('999');
-            expect(preset).toBeUndefined();
-        });
-    });
     describe('addPreset', () => {
         it('should add a new preset', () => {
             mockConfigData.commandPresets = {
                 presets: [{ id: '1', name: 'Main', command: 'claude' }],
                 defaultPresetId: '1',
             };
-            configManager = new ConfigurationManager();
+            resetSavedConfig();
+            configEditor.reload();
             const newPreset = {
                 id: '2',
                 name: 'New Preset',
                 command: 'claude',
                 args: ['--new'],
             };
-            configManager.addPreset(newPreset);
-            const presets = configManager.getCommandPresets();
+            addPreset(configEditor, newPreset);
+            const presets = configEditor.getCommandPresets();
             expect(presets.presets).toHaveLength(2);
             expect(presets.presets[1]).toEqual(newPreset);
         });
@@ -194,15 +155,16 @@ describe('ConfigurationManager - Command Presets', () => {
                 presets: [{ id: '1', name: 'Main', command: 'claude' }],
                 defaultPresetId: '1',
             };
-            configManager = new ConfigurationManager();
+            resetSavedConfig();
+            configEditor.reload();
             const updatedPreset = {
                 id: '1',
                 name: 'Updated Default',
                 command: 'claude',
                 args: ['--updated'],
             };
-            configManager.addPreset(updatedPreset);
-            const presets = configManager.getCommandPresets();
+            addPreset(configEditor, updatedPreset);
+            const presets = configEditor.getCommandPresets();
             expect(presets.presets).toHaveLength(1);
             expect(presets.presets[0]).toEqual(updatedPreset);
         });
@@ -216,9 +178,10 @@ describe('ConfigurationManager - Command Presets', () => {
                 ],
                 defaultPresetId: '1',
             };
-            configManager = new ConfigurationManager();
-            configManager.deletePreset('2');
-            const presets = configManager.getCommandPresets();
+            resetSavedConfig();
+            configEditor.reload();
+            deletePreset(configEditor, '2');
+            const presets = configEditor.getCommandPresets();
             expect(presets.presets).toHaveLength(1);
             expect(presets.presets[0].id).toBe('1');
         });
@@ -227,9 +190,10 @@ describe('ConfigurationManager - Command Presets', () => {
                 presets: [{ id: '1', name: 'Main', command: 'claude' }],
                 defaultPresetId: '1',
             };
-            configManager = new ConfigurationManager();
-            configManager.deletePreset('1');
-            const presets = configManager.getCommandPresets();
+            resetSavedConfig();
+            configEditor.reload();
+            deletePreset(configEditor, '1');
+            const presets = configEditor.getCommandPresets();
             expect(presets.presets).toHaveLength(1);
         });
         it('should update defaultPresetId if default preset is deleted', () => {
@@ -240,9 +204,10 @@ describe('ConfigurationManager - Command Presets', () => {
                 ],
                 defaultPresetId: '2',
             };
-            configManager = new ConfigurationManager();
-            configManager.deletePreset('2');
-            const presets = configManager.getCommandPresets();
+            resetSavedConfig();
+            configEditor.reload();
+            deletePreset(configEditor, '2');
+            const presets = configEditor.getCommandPresets();
             expect(presets.defaultPresetId).toBe('1');
         });
     });
@@ -255,9 +220,10 @@ describe('ConfigurationManager - Command Presets', () => {
                 ],
                 defaultPresetId: '1',
             };
-            configManager = new ConfigurationManager();
-            configManager.setDefaultPreset('2');
-            const presets = configManager.getCommandPresets();
+            resetSavedConfig();
+            configEditor.reload();
+            setDefaultPreset(configEditor, '2');
+            const presets = configEditor.getCommandPresets();
             expect(presets.defaultPresetId).toBe('2');
         });
         it('should not update if preset id does not exist', () => {
@@ -265,49 +231,11 @@ describe('ConfigurationManager - Command Presets', () => {
                 presets: [{ id: '1', name: 'Main', command: 'claude' }],
                 defaultPresetId: '1',
             };
-            configManager = new ConfigurationManager();
-            configManager.setDefaultPreset('999');
-            const presets = configManager.getCommandPresets();
+            resetSavedConfig();
+            configEditor.reload();
+            setDefaultPreset(configEditor, '999');
+            const presets = configEditor.getCommandPresets();
             expect(presets.defaultPresetId).toBe('1');
         });
     });
-    describe('backward compatibility', () => {
-        it('should maintain getCommandConfig for backward compatibility', () => {
-            mockConfigData.commandPresets = {
-                presets: [
-                    { id: '1', name: 'Main', command: 'claude', args: ['--resume'] },
-                    { id: '2', name: 'Custom', command: 'claude', args: ['--custom'] },
-                ],
-                defaultPresetId: '1',
-            };
-            configManager = new ConfigurationManager();
-            const commandConfig = configManager.getCommandConfig();
-            // Should return the default preset as CommandConfig
-            expect(commandConfig).toEqual({
-                command: 'claude',
-                args: ['--resume'],
-            });
-        });
-        it('should update default preset when setCommandConfig is called', () => {
-            mockConfigData.commandPresets = {
-                presets: [{ id: '1', name: 'Main', command: 'claude' }],
-                defaultPresetId: '1',
-            };
-            configManager = new ConfigurationManager();
-            const newConfig = {
-                command: 'claude',
-                args: ['--new-args'],
-                fallbackArgs: ['--new-fallback'],
-            };
-            configManager.setCommandConfig(newConfig);
-            const presets = configManager.getCommandPresets();
-            expect(presets.presets[0]).toEqual({
-                id: '1',
-                name: 'Main',
-                command: 'claude',
-                args: ['--new-args'],
-                fallbackArgs: ['--new-fallback'],
-            });
-        });
-    });
 });

package/dist/services/config/configReader.d.ts

@@ -0,0 +1,28 @@
+import { Either } from 'effect';
+import { ShortcutConfig, StatusHookConfig, WorktreeHookConfig, WorktreeConfig, CommandPresetsConfig, CommandPreset, ConfigurationData, IConfigReader } from '../../types/index.js';
+import { ValidationError } from '../../types/errors.js';
+/**
+ * ConfigReader provides merged configuration reading for runtime components.
+ * It combines project-level config (from `.ccmanager.json`) with global config,
+ * with project config taking priority.
+ *
+ * Uses the singleton projectConfigManager (cwd-based) for project config.
+ */
+export declare class ConfigReader implements IConfigReader {
+    getShortcuts(): ShortcutConfig;
+    getStatusHooks(): StatusHookConfig;
+    getWorktreeHooks(): WorktreeHookConfig;
+    getWorktreeConfig(): WorktreeConfig;
+    getCommandPresets(): CommandPresetsConfig;
+    getConfiguration(): ConfigurationData;
+    getAutoApprovalConfig(): NonNullable<ConfigurationData['autoApproval']>;
+    isAutoApprovalEnabled(): boolean;
+    getDefaultPreset(): CommandPreset;
+    getSelectPresetOnStart(): boolean;
+    getPresetByIdEffect(id: string): Either.Either<CommandPreset, ValidationError>;
+    reload(): void;
+}
+/**
+ * Default singleton instance
+ */
+export declare const configReader: ConfigReader;

package/dist/services/config/configReader.js

@@ -0,0 +1,95 @@
+import { Either } from 'effect';
+import { ValidationError } from '../../types/errors.js';
+import { globalConfigManager } from './globalConfigManager.js';
+import { projectConfigManager } from './projectConfigManager.js';
+/**
+ * ConfigReader provides merged configuration reading for runtime components.
+ * It combines project-level config (from `.ccmanager.json`) with global config,
+ * with project config taking priority.
+ *
+ * Uses the singleton projectConfigManager (cwd-based) for project config.
+ */
+export class ConfigReader {
+    // Shortcuts - returns merged value (project > global)
+    getShortcuts() {
+        return (projectConfigManager.getShortcuts() || globalConfigManager.getShortcuts());
+    }
+    // Status Hooks - returns merged value (project > global)
+    getStatusHooks() {
+        return (projectConfigManager.getStatusHooks() ||
+            globalConfigManager.getStatusHooks());
+    }
+    // Worktree Hooks - returns merged value (project > global)
+    getWorktreeHooks() {
+        return (projectConfigManager.getWorktreeHooks() ||
+            globalConfigManager.getWorktreeHooks());
+    }
+    // Worktree Config - returns merged value (project > global)
+    getWorktreeConfig() {
+        return (projectConfigManager.getWorktreeConfig() ||
+            globalConfigManager.getWorktreeConfig());
+    }
+    // Command Presets - returns merged value (project > global)
+    getCommandPresets() {
+        return (projectConfigManager.getCommandPresets() ||
+            globalConfigManager.getCommandPresets());
+    }
+    // Get full merged configuration
+    getConfiguration() {
+        return {
+            shortcuts: this.getShortcuts(),
+            statusHooks: this.getStatusHooks(),
+            worktreeHooks: this.getWorktreeHooks(),
+            worktree: this.getWorktreeConfig(),
+            commandPresets: this.getCommandPresets(),
+            autoApproval: this.getAutoApprovalConfig(),
+        };
+    }
+    // Auto Approval Config - returns merged value (project > global)
+    getAutoApprovalConfig() {
+        const projectConfig = projectConfigManager.getAutoApprovalConfig();
+        if (projectConfig) {
+            return {
+                ...projectConfig,
+                timeout: projectConfig.timeout ?? 30,
+            };
+        }
+        return globalConfigManager.getAutoApprovalConfig();
+    }
+    // Check if auto-approval is enabled
+    isAutoApprovalEnabled() {
+        return this.getAutoApprovalConfig().enabled;
+    }
+    // Command Preset methods - delegate to global config for modifications
+    getDefaultPreset() {
+        const presets = this.getCommandPresets();
+        const defaultPreset = presets.presets.find(p => p.id === presets.defaultPresetId);
+        return defaultPreset || presets.presets[0];
+    }
+    getSelectPresetOnStart() {
+        const presets = this.getCommandPresets();
+        return presets.selectPresetOnStart ?? false;
+    }
+    // Get preset by ID with Either-based error handling
+    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);
+    }
+    // Reload both project and global configs from disk
+    reload() {
+        projectConfigManager.reload();
+        globalConfigManager.reload();
+    }
+}
+/**
+ * Default singleton instance
+ */
+export const configReader = new ConfigReader();

package/dist/services/config/configReader.multiProject.test.d.ts

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

package/dist/services/config/configReader.multiProject.test.js

@@ -0,0 +1,136 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
+import { ENV_VARS } from '../../constants/env.js';
+// Mock fs module
+vi.mock('fs', () => ({
+    existsSync: vi.fn(),
+    mkdirSync: vi.fn(),
+    readFileSync: vi.fn(),
+    writeFileSync: vi.fn(),
+    unlinkSync: vi.fn(),
+}));
+// Mock os module
+vi.mock('os', () => ({
+    homedir: vi.fn(() => '/home/test'),
+}));
+describe('ConfigReader in multi-project mode', () => {
+    let originalEnv;
+    // Global config data
+    const globalConfigData = {
+        shortcuts: {
+            returnToMenu: { ctrl: true, key: 'g' },
+            cancel: { key: 'escape' },
+        },
+        commandPresets: {
+            presets: [{ id: 'global-1', name: 'Global Preset', command: 'claude' }],
+            defaultPresetId: 'global-1',
+        },
+        worktree: {
+            autoDirectory: false,
+            copySessionData: true,
+            sortByLastSession: false,
+        },
+        autoApproval: {
+            enabled: false,
+            timeout: 30,
+        },
+    };
+    // Project config data (should be ignored in multi-project mode)
+    const projectConfigData = {
+        shortcuts: {
+            returnToMenu: { ctrl: true, key: 'p' },
+            cancel: { key: 'q' },
+        },
+        commandPresets: {
+            presets: [
+                { id: 'project-1', name: 'Project Preset', command: 'claude-project' },
+            ],
+            defaultPresetId: 'project-1',
+        },
+    };
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.resetModules();
+        // Save original env
+        originalEnv = process.env[ENV_VARS.MULTI_PROJECT_ROOT];
+        // Mock file system
+        existsSync.mockImplementation((path) => {
+            if (path.includes('.ccmanager.json')) {
+                return true; // Project config exists
+            }
+            if (path.includes('config.json')) {
+                return true; // Global config exists
+            }
+            return false;
+        });
+        readFileSync.mockImplementation((path) => {
+            if (path.includes('.ccmanager.json')) {
+                return JSON.stringify(projectConfigData);
+            }
+            if (path.includes('config.json')) {
+                return JSON.stringify(globalConfigData);
+            }
+            return '{}';
+        });
+        mkdirSync.mockImplementation(() => { });
+        writeFileSync.mockImplementation(() => { });
+    });
+    afterEach(() => {
+        // Restore original env
+        if (originalEnv !== undefined) {
+            process.env[ENV_VARS.MULTI_PROJECT_ROOT] = originalEnv;
+        }
+        else {
+            delete process.env[ENV_VARS.MULTI_PROJECT_ROOT];
+        }
+        vi.resetAllMocks();
+    });
+    it('should return global config when CCMANAGER_MULTI_PROJECT_ROOT is set', async () => {
+        // Set multi-project mode
+        process.env[ENV_VARS.MULTI_PROJECT_ROOT] = '/path/to/projects';
+        // Dynamic import to pick up the env var
+        const { ConfigReader } = await import('./configReader.js');
+        const reader = new ConfigReader();
+        reader.reload();
+        // Verify global config is returned (not project config)
+        const shortcuts = reader.getShortcuts();
+        expect(shortcuts.returnToMenu).toEqual({ ctrl: true, key: 'g' });
+        const presets = reader.getCommandPresets();
+        expect(presets.presets[0].id).toBe('global-1');
+        expect(presets.presets[0].name).toBe('Global Preset');
+    });
+    it('should return project config when CCMANAGER_MULTI_PROJECT_ROOT is not set', async () => {
+        // Ensure multi-project mode is NOT set
+        delete process.env[ENV_VARS.MULTI_PROJECT_ROOT];
+        // Dynamic import
+        const { ConfigReader } = await import('./configReader.js');
+        const reader = new ConfigReader();
+        reader.reload();
+        // Verify project config takes priority
+        const shortcuts = reader.getShortcuts();
+        expect(shortcuts.returnToMenu).toEqual({ ctrl: true, key: 'p' });
+        const presets = reader.getCommandPresets();
+        expect(presets.presets[0].id).toBe('project-1');
+        expect(presets.presets[0].name).toBe('Project Preset');
+    });
+    it('should return global autoApproval config in multi-project mode', async () => {
+        // Set multi-project mode
+        process.env[ENV_VARS.MULTI_PROJECT_ROOT] = '/path/to/projects';
+        const { ConfigReader } = await import('./configReader.js');
+        const reader = new ConfigReader();
+        reader.reload();
+        const autoApproval = reader.getAutoApprovalConfig();
+        expect(autoApproval.enabled).toBe(false);
+        expect(autoApproval.timeout).toBe(30);
+    });
+    it('should return global worktree config in multi-project mode', async () => {
+        // Set multi-project mode
+        process.env[ENV_VARS.MULTI_PROJECT_ROOT] = '/path/to/projects';
+        const { ConfigReader } = await import('./configReader.js');
+        const reader = new ConfigReader();
+        reader.reload();
+        const worktreeConfig = reader.getWorktreeConfig();
+        expect(worktreeConfig.autoDirectory).toBe(false);
+        expect(worktreeConfig.copySessionData).toBe(true);
+    });
+});

package/dist/services/config/globalConfigManager.d.ts

@@ -0,0 +1,30 @@
+import { ConfigurationData, StatusHookConfig, WorktreeHookConfig, ShortcutConfig, WorktreeConfig, CommandPresetsConfig, IConfigEditor } from '../../types/index.js';
+declare class GlobalConfigManager implements IConfigEditor {
+    private configPath;
+    private legacyShortcutsPath;
+    private configDir;
+    private config;
+    constructor();
+    private loadConfig;
+    private migrateLegacyShortcuts;
+    private saveConfig;
+    getShortcuts(): ShortcutConfig;
+    setShortcuts(shortcuts: ShortcutConfig): void;
+    getStatusHooks(): StatusHookConfig;
+    setStatusHooks(hooks: StatusHookConfig): void;
+    getWorktreeHooks(): WorktreeHookConfig;
+    setWorktreeHooks(hooks: WorktreeHookConfig): void;
+    getWorktreeConfig(): WorktreeConfig;
+    setWorktreeConfig(worktreeConfig: WorktreeConfig): void;
+    getAutoApprovalConfig(): NonNullable<ConfigurationData['autoApproval']>;
+    setAutoApprovalConfig(autoApproval: NonNullable<ConfigurationData['autoApproval']>): void;
+    private ensureDefaultPresets;
+    getCommandPresets(): CommandPresetsConfig;
+    setCommandPresets(presets: CommandPresetsConfig): void;
+    /**
+     * Reload configuration from disk
+     */
+    reload(): void;
+}
+export declare const globalConfigManager: GlobalConfigManager;
+export {};