ccmanager 3.3.2 → 3.5.0

package/dist/contexts/ConfigEditorContext.js

@@ -0,0 +1,25 @@
+import React, { createContext, useContext, useMemo } from 'react';
+import { ConfigEditor } from '../services/config/configEditor.js';
+const ConfigEditorContext = createContext(null);
+/**
+ * Provider component for ConfigEditor context.
+ * Creates a ConfigEditor instance based on scope.
+ * Uses singleton config editors to ensure config changes are
+ * immediately visible to all components.
+ */
+export function ConfigEditorProvider({ scope, children, }) {
+    const configEditor = useMemo(() => new ConfigEditor(scope), [scope]);
+    return (React.createElement(ConfigEditorContext.Provider, { value: configEditor }, children));
+}
+/**
+ * Hook to access ConfigEditor from context.
+ * Must be used within a ConfigEditorProvider.
+ */
+export function useConfigEditor() {
+    const context = useContext(ConfigEditorContext);
+    if (context === null) {
+        throw new Error('useConfigEditor must be used within a ConfigEditorProvider');
+    }
+    return context;
+}
+export { ConfigEditorContext };

package/dist/services/autoApprovalVerifier.js

@@ -1,11 +1,11 @@
 import { Effect } from 'effect';
 import { ProcessError } from '../types/errors.js';
-import { configurationManager } from './configurationManager.js';
+import { configReader } from './config/configReader.js';
 import { logger } from '../utils/logger.js';
 import { execFile, spawn, } from 'child_process';
 const DEFAULT_TIMEOUT_SECONDS = 30;
 const getTimeoutMs = () => {
-    const config = configurationManager.getAutoApprovalConfig();
+    const config = configReader.getAutoApprovalConfig();
     const timeoutSeconds = config.timeout ?? DEFAULT_TIMEOUT_SECONDS;
     return timeoutSeconds * 1000;
 };
@@ -222,7 +222,7 @@ export class AutoApprovalVerifier {
     verifyNeedsPermission(terminalOutput, options) {
         const attemptVerification = Effect.tryPromise({
             try: async () => {
-                const autoApprovalConfig = configurationManager.getAutoApprovalConfig();
+                const autoApprovalConfig = configReader.getAutoApprovalConfig();
                 const customCommand = autoApprovalConfig.customCommand?.trim();
                 const prompt = buildPrompt(terminalOutput);
                 const jsonSchema = JSON.stringify({

package/dist/services/autoApprovalVerifier.test.js

@@ -5,8 +5,8 @@ const execFileMock = vi.fn();
 vi.mock('child_process', () => ({
     execFile: (...args) => execFileMock(...args),
 }));
-vi.mock('./configurationManager.js', () => ({
-    configurationManager: {
+vi.mock('./config/configReader.js', () => ({
+    configReader: {
         getAutoApprovalConfig: vi.fn().mockReturnValue({ enabled: false }),
     },
 }));

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

@@ -0,0 +1,46 @@
+import { ConfigScope, ProjectConfigurationData, ShortcutConfig, StatusHookConfig, WorktreeHookConfig, WorktreeConfig, CommandPresetsConfig, IConfigEditor, AutoApprovalConfig } from '../../types/index.js';
+/**
+ * ConfigEditor provides scope-aware configuration editing.
+ * The scope is determined at construction time.
+ *
+ * - When scope='global', uses GlobalConfigManager singleton
+ * - When scope='project', uses ProjectConfigManager singleton
+ *   (with fallback to global if project value is undefined)
+ *
+ * IMPORTANT: Uses singletons to ensure that config changes are
+ * immediately visible to all components (e.g., shortcutManager, configReader).
+ */
+export declare class ConfigEditor implements IConfigEditor {
+    private scope;
+    private configEditor;
+    constructor(scope: ConfigScope);
+    getShortcuts(): ShortcutConfig | undefined;
+    setShortcuts(value: ShortcutConfig): void;
+    getStatusHooks(): StatusHookConfig | undefined;
+    setStatusHooks(value: StatusHookConfig): void;
+    getWorktreeHooks(): WorktreeHookConfig | undefined;
+    setWorktreeHooks(value: WorktreeHookConfig): void;
+    getWorktreeConfig(): WorktreeConfig | undefined;
+    setWorktreeConfig(value: WorktreeConfig): void;
+    getCommandPresets(): CommandPresetsConfig | undefined;
+    setCommandPresets(value: CommandPresetsConfig): void;
+    getAutoApprovalConfig(): AutoApprovalConfig | undefined;
+    setAutoApprovalConfig(value: AutoApprovalConfig): void;
+    reload(): void;
+    /**
+     * Get the current scope
+     */
+    getScope(): ConfigScope;
+    /**
+     * Check if project has an override for a specific field
+     */
+    hasProjectOverride(field: keyof ProjectConfigurationData): boolean;
+    /**
+     * Remove project override for a specific field
+     */
+    removeProjectOverride(field: keyof ProjectConfigurationData): void;
+}
+/**
+ * Factory function to create a ConfigEditor instance
+ */
+export declare function createConfigEditor(scope: ConfigScope): ConfigEditor;

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

@@ -1,7 +1,11 @@
 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';
+import { ConfigEditor } from './configEditor.js';
+import { loadConfigEffect, validateConfig, saveConfigEffect, setShortcutsEffect, setCommandPresetsEffect, addPresetEffect, deletePresetEffect, setDefaultPresetEffect, getPresetByIdEffect, } from './testUtils.js';
+// Test paths (matching what GlobalConfigManager constructs with mocked homedir)
+const TEST_CONFIG_PATH = '/home/test/.config/ccmanager/config.json';
+const TEST_LEGACY_SHORTCUTS_PATH = '/home/test/.config/ccmanager/shortcuts.json';
 // Mock fs module
 vi.mock('fs', () => ({
     existsSync: vi.fn(),
@@ -13,8 +17,8 @@ vi.mock('fs', () => ({
 vi.mock('os', () => ({
     homedir: vi.fn(() => '/home/test'),
 }));
-describe('ConfigurationManager - Effect-based operations', () => {
-    let configManager;
+describe('ConfigEditor (global scope) - Effect-based operations', () => {
+    let configEditor;
     let mockConfigData;
     beforeEach(() => {
         // Reset all mocks
@@ -25,10 +29,6 @@ describe('ConfigurationManager - Effect-based operations', () => {
                 returnToMenu: { ctrl: true, key: 'e' },
                 cancel: { key: 'escape' },
             },
-            command: {
-                command: 'claude',
-                args: ['--existing'],
-            },
         };
         // Mock file system operations
         existsSync.mockImplementation((path) => {
@@ -39,25 +39,24 @@ describe('ConfigurationManager - Effect-based operations', () => {
         });
         mkdirSync.mockImplementation(() => { });
         writeFileSync.mockImplementation(() => { });
-        // Create new instance for each test
-        configManager = new ConfigurationManager();
+        // Create new instance for each test and reload to pick up mocked fs
+        configEditor = new ConfigEditor('global');
+        configEditor.reload();
     });
     afterEach(() => {
         vi.resetAllMocks();
     });
     describe('loadConfigEffect', () => {
         it('should return Effect with ConfigurationData on success', async () => {
-            const result = await Effect.runPromise(configManager.loadConfigEffect());
+            const result = await Effect.runPromise(loadConfigEffect(TEST_CONFIG_PATH, TEST_LEGACY_SHORTCUTS_PATH));
             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()));
+            const result = await Effect.runPromise(Effect.either(loadConfigEffect(TEST_CONFIG_PATH, TEST_LEGACY_SHORTCUTS_PATH)));
             expect(Either.isLeft(result)).toBe(true);
             if (Either.isLeft(result)) {
                 expect(result.left._tag).toBe('FileSystemError');
@@ -69,8 +68,7 @@ describe('ConfigurationManager - Effect-based operations', () => {
             readFileSync.mockImplementation(() => {
                 return 'invalid json{';
             });
-            configManager = new ConfigurationManager();
-            const result = await Effect.runPromise(Effect.either(configManager.loadConfigEffect()));
+            const result = await Effect.runPromise(Effect.either(loadConfigEffect(TEST_CONFIG_PATH, TEST_LEGACY_SHORTCUTS_PATH)));
             expect(Either.isLeft(result)).toBe(true);
             if (Either.isLeft(result)) {
                 expect(result.left._tag).toBe('ConfigError');
@@ -94,8 +92,7 @@ describe('ConfigurationManager - Effect-based operations', () => {
                 }
                 return '{}';
             });
-            configManager = new ConfigurationManager();
-            const result = await Effect.runPromise(configManager.loadConfigEffect());
+            const result = await Effect.runPromise(loadConfigEffect(TEST_CONFIG_PATH, TEST_LEGACY_SHORTCUTS_PATH));
             expect(result.shortcuts).toEqual(legacyShortcuts);
             expect(writeFileSync).toHaveBeenCalled();
         });
@@ -108,7 +105,7 @@ describe('ConfigurationManager - Effect-based operations', () => {
                     cancel: { key: 'escape' },
                 },
             };
-            await Effect.runPromise(configManager.saveConfigEffect(newConfig));
+            await Effect.runPromise(saveConfigEffect(configEditor, newConfig, TEST_CONFIG_PATH));
             expect(writeFileSync).toHaveBeenCalledWith(expect.stringContaining('config.json'), expect.any(String));
         });
         it('should fail with FileSystemError when file write fails', async () => {
@@ -121,7 +118,7 @@ describe('ConfigurationManager - Effect-based operations', () => {
                     cancel: { key: 'escape' },
                 },
             };
-            const result = await Effect.runPromise(Effect.either(configManager.saveConfigEffect(newConfig)));
+            const result = await Effect.runPromise(Effect.either(saveConfigEffect(configEditor, newConfig, TEST_CONFIG_PATH)));
             expect(Either.isLeft(result)).toBe(true);
             if (Either.isLeft(result)) {
                 expect(result.left._tag).toBe('FileSystemError');
@@ -138,7 +135,7 @@ describe('ConfigurationManager - Effect-based operations', () => {
                     cancel: { key: 'escape' },
                 },
             };
-            const result = configManager.validateConfig(validConfig);
+            const result = validateConfig(validConfig);
             expect(Either.isRight(result)).toBe(true);
             if (Either.isRight(result)) {
                 expect(result.right).toEqual(validConfig);
@@ -148,7 +145,7 @@ describe('ConfigurationManager - Effect-based operations', () => {
             const invalidConfig = {
                 shortcuts: 'not an object',
             };
-            const result = configManager.validateConfig(invalidConfig);
+            const result = validateConfig(invalidConfig);
             expect(Either.isLeft(result)).toBe(true);
             if (Either.isLeft(result)) {
                 const error = result.left;
@@ -157,7 +154,7 @@ describe('ConfigurationManager - Effect-based operations', () => {
             }
         });
         it('should return Left for null config', () => {
-            const result = configManager.validateConfig(null);
+            const result = validateConfig(null);
             expect(Either.isLeft(result)).toBe(true);
             if (Either.isLeft(result)) {
                 const error = result.left;
@@ -174,8 +171,8 @@ describe('ConfigurationManager - Effect-based operations', () => {
                 ],
                 defaultPresetId: '1',
             };
-            configManager = new ConfigurationManager();
-            const result = configManager.getPresetByIdEffect('2');
+            configEditor.reload();
+            const result = getPresetByIdEffect(configEditor, '2');
             expect(Either.isRight(result)).toBe(true);
             if (Either.isRight(result)) {
                 expect(result.right).toEqual({
@@ -191,8 +188,8 @@ describe('ConfigurationManager - Effect-based operations', () => {
                 presets: [{ id: '1', name: 'Main', command: 'claude' }],
                 defaultPresetId: '1',
             };
-            configManager = new ConfigurationManager();
-            const result = configManager.getPresetByIdEffect('999');
+            configEditor.reload();
+            const result = getPresetByIdEffect(configEditor, '999');
             expect(Either.isLeft(result)).toBe(true);
             if (Either.isLeft(result)) {
                 const error = result.left;
@@ -206,8 +203,8 @@ describe('ConfigurationManager - Effect-based operations', () => {
                 presets: [{ id: '1', name: 'Main', command: 'claude' }],
                 defaultPresetId: '1',
             };
-            configManager = new ConfigurationManager();
-            const result = configManager.getPresetByIdEffect('invalid-id');
+            configEditor.reload();
+            const result = getPresetByIdEffect(configEditor, 'invalid-id');
             expect(Either.isLeft(result)).toBe(true);
             if (Either.isLeft(result)) {
                 const error = result.left;
@@ -221,7 +218,7 @@ describe('ConfigurationManager - Effect-based operations', () => {
                 returnToMenu: { ctrl: true, key: 'z' },
                 cancel: { key: 'escape' },
             };
-            await Effect.runPromise(configManager.setShortcutsEffect(newShortcuts));
+            await Effect.runPromise(setShortcutsEffect(configEditor, newShortcuts, TEST_CONFIG_PATH));
             expect(writeFileSync).toHaveBeenCalled();
         });
         it('should fail with FileSystemError when save fails', async () => {
@@ -232,7 +229,7 @@ describe('ConfigurationManager - Effect-based operations', () => {
                 returnToMenu: { ctrl: true, key: 'z' },
                 cancel: { key: 'escape' },
             };
-            const result = await Effect.runPromise(Effect.either(configManager.setShortcutsEffect(newShortcuts)));
+            const result = await Effect.runPromise(Effect.either(setShortcutsEffect(configEditor, newShortcuts, TEST_CONFIG_PATH)));
             expect(Either.isLeft(result)).toBe(true);
             if (Either.isLeft(result)) {
                 expect(result.left._tag).toBe('FileSystemError');
@@ -248,7 +245,7 @@ describe('ConfigurationManager - Effect-based operations', () => {
                 ],
                 defaultPresetId: '2',
             };
-            await Effect.runPromise(configManager.setCommandPresetsEffect(newPresets));
+            await Effect.runPromise(setCommandPresetsEffect(configEditor, newPresets, TEST_CONFIG_PATH));
             expect(writeFileSync).toHaveBeenCalled();
         });
         it('should fail with FileSystemError when save fails', async () => {
@@ -259,7 +256,7 @@ describe('ConfigurationManager - Effect-based operations', () => {
                 presets: [{ id: '1', name: 'Main', command: 'claude' }],
                 defaultPresetId: '1',
             };
-            const result = await Effect.runPromise(Effect.either(configManager.setCommandPresetsEffect(newPresets)));
+            const result = await Effect.runPromise(Effect.either(setCommandPresetsEffect(configEditor, newPresets, TEST_CONFIG_PATH)));
             expect(Either.isLeft(result)).toBe(true);
             if (Either.isLeft(result)) {
                 expect(result.left._tag).toBe('FileSystemError');
@@ -272,14 +269,14 @@ describe('ConfigurationManager - Effect-based operations', () => {
                 presets: [{ id: '1', name: 'Main', command: 'claude' }],
                 defaultPresetId: '1',
             };
-            configManager = new ConfigurationManager();
+            configEditor.reload();
             const newPreset = {
                 id: '2',
                 name: 'New',
                 command: 'claude',
                 args: ['--new'],
             };
-            await Effect.runPromise(configManager.addPresetEffect(newPreset));
+            await Effect.runPromise(addPresetEffect(configEditor, newPreset, TEST_CONFIG_PATH));
             expect(writeFileSync).toHaveBeenCalled();
         });
         it('should replace existing preset with same id', async () => {
@@ -287,14 +284,14 @@ describe('ConfigurationManager - Effect-based operations', () => {
                 presets: [{ id: '1', name: 'Main', command: 'claude' }],
                 defaultPresetId: '1',
             };
-            configManager = new ConfigurationManager();
+            configEditor.reload();
             const updatedPreset = {
                 id: '1',
                 name: 'Updated',
                 command: 'claude',
                 args: ['--updated'],
             };
-            await Effect.runPromise(configManager.addPresetEffect(updatedPreset));
+            await Effect.runPromise(addPresetEffect(configEditor, updatedPreset, TEST_CONFIG_PATH));
             expect(writeFileSync).toHaveBeenCalled();
         });
         it('should fail with FileSystemError when save fails', async () => {
@@ -306,7 +303,7 @@ describe('ConfigurationManager - Effect-based operations', () => {
                 name: 'New',
                 command: 'claude',
             };
-            const result = await Effect.runPromise(Effect.either(configManager.addPresetEffect(newPreset)));
+            const result = await Effect.runPromise(Effect.either(addPresetEffect(configEditor, newPreset, TEST_CONFIG_PATH)));
             expect(Either.isLeft(result)).toBe(true);
             if (Either.isLeft(result)) {
                 expect(result.left._tag).toBe('FileSystemError');
@@ -322,8 +319,8 @@ describe('ConfigurationManager - Effect-based operations', () => {
                 ],
                 defaultPresetId: '1',
             };
-            configManager = new ConfigurationManager();
-            await Effect.runPromise(configManager.deletePresetEffect('2'));
+            configEditor.reload();
+            await Effect.runPromise(deletePresetEffect(configEditor, '2', TEST_CONFIG_PATH));
             expect(writeFileSync).toHaveBeenCalled();
         });
         it('should fail with ValidationError when deleting last preset', async () => {
@@ -331,8 +328,8 @@ describe('ConfigurationManager - Effect-based operations', () => {
                 presets: [{ id: '1', name: 'Main', command: 'claude' }],
                 defaultPresetId: '1',
             };
-            configManager = new ConfigurationManager();
-            const result = await Effect.runPromise(Effect.either(configManager.deletePresetEffect('1')));
+            configEditor.reload();
+            const result = await Effect.runPromise(Effect.either(deletePresetEffect(configEditor, '1', TEST_CONFIG_PATH)));
             expect(Either.isLeft(result)).toBe(true);
             if (Either.isLeft(result)) {
                 expect(result.left._tag).toBe('ValidationError');
@@ -348,11 +345,11 @@ describe('ConfigurationManager - Effect-based operations', () => {
                 ],
                 defaultPresetId: '1',
             };
-            configManager = new ConfigurationManager();
+            configEditor.reload();
             writeFileSync.mockImplementation(() => {
                 throw new Error('Save failed');
             });
-            const result = await Effect.runPromise(Effect.either(configManager.deletePresetEffect('2')));
+            const result = await Effect.runPromise(Effect.either(deletePresetEffect(configEditor, '2', TEST_CONFIG_PATH)));
             expect(Either.isLeft(result)).toBe(true);
             if (Either.isLeft(result)) {
                 expect(result.left._tag).toBe('FileSystemError');
@@ -368,8 +365,8 @@ describe('ConfigurationManager - Effect-based operations', () => {
                 ],
                 defaultPresetId: '1',
             };
-            configManager = new ConfigurationManager();
-            await Effect.runPromise(configManager.setDefaultPresetEffect('2'));
+            configEditor.reload();
+            await Effect.runPromise(setDefaultPresetEffect(configEditor, '2', TEST_CONFIG_PATH));
             expect(writeFileSync).toHaveBeenCalled();
         });
         it('should fail with ValidationError when preset id does not exist', async () => {
@@ -377,8 +374,8 @@ describe('ConfigurationManager - Effect-based operations', () => {
                 presets: [{ id: '1', name: 'Main', command: 'claude' }],
                 defaultPresetId: '1',
             };
-            configManager = new ConfigurationManager();
-            const result = await Effect.runPromise(Effect.either(configManager.setDefaultPresetEffect('999')));
+            configEditor.reload();
+            const result = await Effect.runPromise(Effect.either(setDefaultPresetEffect(configEditor, '999', TEST_CONFIG_PATH)));
             expect(Either.isLeft(result)).toBe(true);
             if (Either.isLeft(result)) {
                 expect(result.left._tag).toBe('ValidationError');
@@ -393,11 +390,11 @@ describe('ConfigurationManager - Effect-based operations', () => {
                 ],
                 defaultPresetId: '1',
             };
-            configManager = new ConfigurationManager();
+            configEditor.reload();
             writeFileSync.mockImplementation(() => {
                 throw new Error('Save failed');
             });
-            const result = await Effect.runPromise(Effect.either(configManager.setDefaultPresetEffect('2')));
+            const result = await Effect.runPromise(Effect.either(setDefaultPresetEffect(configEditor, '2', TEST_CONFIG_PATH)));
             expect(Either.isLeft(result)).toBe(true);
             if (Either.isLeft(result)) {
                 expect(result.left._tag).toBe('FileSystemError');

package/dist/services/config/configEditor.js

@@ -0,0 +1,101 @@
+import { globalConfigManager } from './globalConfigManager.js';
+import { projectConfigManager } from './projectConfigManager.js';
+/**
+ * ConfigEditor provides scope-aware configuration editing.
+ * The scope is determined at construction time.
+ *
+ * - When scope='global', uses GlobalConfigManager singleton
+ * - When scope='project', uses ProjectConfigManager singleton
+ *   (with fallback to global if project value is undefined)
+ *
+ * IMPORTANT: Uses singletons to ensure that config changes are
+ * immediately visible to all components (e.g., shortcutManager, configReader).
+ */
+export class ConfigEditor {
+    constructor(scope) {
+        Object.defineProperty(this, "scope", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "configEditor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.scope = scope;
+        this.configEditor =
+            scope === 'global' ? globalConfigManager : projectConfigManager;
+    }
+    // IConfigEditor implementation - delegates to configEditor with fallback to global
+    getShortcuts() {
+        return (this.configEditor.getShortcuts() ?? globalConfigManager.getShortcuts());
+    }
+    setShortcuts(value) {
+        this.configEditor.setShortcuts(value);
+    }
+    getStatusHooks() {
+        return (this.configEditor.getStatusHooks() ?? globalConfigManager.getStatusHooks());
+    }
+    setStatusHooks(value) {
+        this.configEditor.setStatusHooks(value);
+    }
+    getWorktreeHooks() {
+        return (this.configEditor.getWorktreeHooks() ??
+            globalConfigManager.getWorktreeHooks());
+    }
+    setWorktreeHooks(value) {
+        this.configEditor.setWorktreeHooks(value);
+    }
+    getWorktreeConfig() {
+        return (this.configEditor.getWorktreeConfig() ??
+            globalConfigManager.getWorktreeConfig());
+    }
+    setWorktreeConfig(value) {
+        this.configEditor.setWorktreeConfig(value);
+    }
+    getCommandPresets() {
+        return (this.configEditor.getCommandPresets() ??
+            globalConfigManager.getCommandPresets());
+    }
+    setCommandPresets(value) {
+        this.configEditor.setCommandPresets(value);
+    }
+    getAutoApprovalConfig() {
+        return (this.configEditor.getAutoApprovalConfig() ??
+            globalConfigManager.getAutoApprovalConfig());
+    }
+    setAutoApprovalConfig(value) {
+        this.configEditor.setAutoApprovalConfig(value);
+    }
+    reload() {
+        this.configEditor.reload();
+    }
+    // Helper methods
+    /**
+     * Get the current scope
+     */
+    getScope() {
+        return this.scope;
+    }
+    /**
+     * Check if project has an override for a specific field
+     */
+    hasProjectOverride(field) {
+        return projectConfigManager.hasOverride(field);
+    }
+    /**
+     * Remove project override for a specific field
+     */
+    removeProjectOverride(field) {
+        projectConfigManager.removeOverride(field);
+    }
+}
+/**
+ * Factory function to create a ConfigEditor instance
+ */
+export function createConfigEditor(scope) {
+    return new ConfigEditor(scope);
+}

package/dist/services/{configurationManager.selectPresetOnStart.test.js → config/configEditor.selectPresetOnStart.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 { getSelectPresetOnStart, setSelectPresetOnStart } from './testUtils.js';
 // Mock fs module
 vi.mock('fs', () => ({
     existsSync: vi.fn(),
@@ -12,12 +13,14 @@ vi.mock('fs', () => ({
 vi.mock('os', () => ({
     homedir: vi.fn(() => '/home/test'),
 }));
-describe('ConfigurationManager - selectPresetOnStart', () => {
-    let configManager;
+describe('ConfigEditor (global scope) - selectPresetOnStart', () => {
+    let configEditor;
     let mockConfigData;
+    let savedConfigData = null;
     beforeEach(() => {
         // Reset all mocks
         vi.clearAllMocks();
+        savedConfigData = null;
         // Default mock config data
         mockConfigData = {
             shortcuts: {
@@ -46,55 +49,60 @@ describe('ConfigurationManager - selectPresetOnStart', () => {
             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('getSelectPresetOnStart', () => {
         it('should return false by default', () => {
-            const result = configManager.getSelectPresetOnStart();
+            const result = getSelectPresetOnStart(configEditor);
             expect(result).toBe(false);
         });
         it('should return true when configured', () => {
             mockConfigData.commandPresets.selectPresetOnStart = true;
-            configManager = new ConfigurationManager();
-            const result = configManager.getSelectPresetOnStart();
+            configEditor.reload();
+            const result = getSelectPresetOnStart(configEditor);
             expect(result).toBe(true);
         });
         it('should return false when explicitly set to false', () => {
             mockConfigData.commandPresets.selectPresetOnStart = false;
-            configManager = new ConfigurationManager();
-            const result = configManager.getSelectPresetOnStart();
+            configEditor.reload();
+            const result = getSelectPresetOnStart(configEditor);
             expect(result).toBe(false);
         });
     });
     describe('setSelectPresetOnStart', () => {
         it('should set selectPresetOnStart to true', () => {
-            configManager.setSelectPresetOnStart(true);
-            const result = configManager.getSelectPresetOnStart();
+            setSelectPresetOnStart(configEditor, true);
+            const result = getSelectPresetOnStart(configEditor);
             expect(result).toBe(true);
             // Verify that config was saved
             expect(writeFileSync).toHaveBeenCalledWith(expect.stringContaining('config.json'), expect.stringContaining('"selectPresetOnStart": true'));
         });
         it('should set selectPresetOnStart to false', () => {
             // First set to true
-            configManager.setSelectPresetOnStart(true);
+            setSelectPresetOnStart(configEditor, true);
             // Then set to false
-            configManager.setSelectPresetOnStart(false);
-            const result = configManager.getSelectPresetOnStart();
+            setSelectPresetOnStart(configEditor, false);
+            const result = getSelectPresetOnStart(configEditor);
             expect(result).toBe(false);
             // Verify that config was saved
             expect(writeFileSync).toHaveBeenLastCalledWith(expect.stringContaining('config.json'), expect.stringContaining('"selectPresetOnStart": false'));
         });
         it('should preserve other preset configuration when setting selectPresetOnStart', () => {
-            configManager.setSelectPresetOnStart(true);
-            const presets = configManager.getCommandPresets();
+            setSelectPresetOnStart(configEditor, true);
+            const presets = configEditor.getCommandPresets();
             expect(presets.presets).toHaveLength(2);
             expect(presets.defaultPresetId).toBe('1');
             expect(presets.selectPresetOnStart).toBe(true);

package/dist/services/config/configEditor.test.d.ts

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