ccmanager 3.4.0 → 3.5.0

package/dist/components/ConfigureStatusHooks.test.js

@@ -2,7 +2,7 @@ import React from 'react';
 import { render } from 'ink-testing-library';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import ConfigureStatusHooks from './ConfigureStatusHooks.js';
-import { configurationManager } from '../services/configurationManager.js';
+import { ConfigEditorProvider } from '../contexts/ConfigEditorContext.js';
 // Mock ink to avoid stdin issues
 vi.mock('ink', async () => {
     const actual = await vi.importActual('ink');
@@ -21,21 +21,54 @@ vi.mock('ink-select-input', async () => {
         },
     };
 });
-vi.mock('../services/configurationManager.js', () => ({
-    configurationManager: {
-        getStatusHooks: vi.fn(),
-        setStatusHooks: vi.fn(),
-    },
-}));
-const mockedConfigurationManager = configurationManager;
+// Create mock functions that will be used by the mock class
+const mockFns = {
+    getStatusHooks: vi.fn(),
+    setStatusHooks: vi.fn(),
+    hasProjectOverride: vi.fn().mockReturnValue(false),
+    getScope: vi.fn().mockReturnValue('global'),
+};
+vi.mock('../services/config/configEditor.js', () => {
+    return {
+        ConfigEditor: class {
+            constructor() {
+                Object.defineProperty(this, "getStatusHooks", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: mockFns.getStatusHooks
+                });
+                Object.defineProperty(this, "setStatusHooks", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: mockFns.setStatusHooks
+                });
+                Object.defineProperty(this, "hasProjectOverride", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: mockFns.hasProjectOverride
+                });
+                Object.defineProperty(this, "getScope", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: mockFns.getScope
+                });
+            }
+        },
+    };
+});
 describe('ConfigureStatusHooks', () => {
     beforeEach(() => {
         vi.clearAllMocks();
     });
     it('should render status hooks configuration screen', () => {
-        mockedConfigurationManager.getStatusHooks.mockReturnValue({});
+        mockFns.getStatusHooks.mockReturnValue({});
         const onComplete = vi.fn();
-        const { lastFrame } = render(React.createElement(ConfigureStatusHooks, { onComplete: onComplete }));
+        const { lastFrame } = render(React.createElement(ConfigEditorProvider, { scope: "global" },
+            React.createElement(ConfigureStatusHooks, { onComplete: onComplete })));
         expect(lastFrame()).toContain('Configure Status Hooks');
         expect(lastFrame()).toContain('Set commands to run when session status changes');
         expect(lastFrame()).toContain('Idle:');
@@ -43,7 +76,7 @@ describe('ConfigureStatusHooks', () => {
         expect(lastFrame()).toContain('Waiting for Input:');
     });
     it('should display configured hooks', () => {
-        mockedConfigurationManager.getStatusHooks.mockReturnValue({
+        mockFns.getStatusHooks.mockReturnValue({
             idle: {
                 command: 'notify-send "Idle"',
                 enabled: true,
@@ -54,7 +87,8 @@ describe('ConfigureStatusHooks', () => {
             },
         });
         const onComplete = vi.fn();
-        const { lastFrame } = render(React.createElement(ConfigureStatusHooks, { onComplete: onComplete }));
+        const { lastFrame } = render(React.createElement(ConfigEditorProvider, { scope: "global" },
+            React.createElement(ConfigureStatusHooks, { onComplete: onComplete })));
         expect(lastFrame()).toContain('Idle: ✓ notify-send "Idle"');
         expect(lastFrame()).toContain('Busy: ✗ echo "Busy"');
         expect(lastFrame()).toContain('Waiting for Input: ✗ (not set)');

package/dist/components/ConfigureWorktree.js

@@ -2,17 +2,22 @@ import React, { useState } from 'react';
 import { Box, Text, useInput } from 'ink';
 import SelectInput from 'ink-select-input';
 import TextInputWrapper from './TextInputWrapper.js';
-import { configurationManager } from '../services/configurationManager.js';
+import { useConfigEditor } from '../contexts/ConfigEditorContext.js';
 import { shortcutManager } from '../services/shortcutManager.js';
 import { generateWorktreeDirectory } from '../utils/worktreeUtils.js';
 const ConfigureWorktree = ({ onComplete }) => {
-    const worktreeConfig = configurationManager.getWorktreeConfig();
+    const configEditor = useConfigEditor();
+    const scope = configEditor.getScope();
+    // Get initial worktree config based on scope
+    const worktreeConfig = configEditor.getWorktreeConfig();
     const [autoDirectory, setAutoDirectory] = useState(worktreeConfig.autoDirectory);
     const [pattern, setPattern] = useState(worktreeConfig.autoDirectoryPattern || '../{branch}');
     const [copySessionData, setCopySessionData] = useState(worktreeConfig.copySessionData ?? true);
     const [sortByLastSession, setSortByLastSession] = useState(worktreeConfig.sortByLastSession ?? false);
     const [editMode, setEditMode] = useState('menu');
     const [tempPattern, setTempPattern] = useState(pattern);
+    // Show if inheriting from global (for project scope)
+    const isInheriting = scope === 'project' && !configEditor.hasProjectOverride('worktree');
     // Example values for preview
     const exampleProjectPath = '/home/user/src/myproject';
     const exampleBranchName = 'feature/my-feature';
@@ -65,7 +70,7 @@ const ConfigureWorktree = ({ onComplete }) => {
                 break;
             case 'save':
                 // Save the configuration
-                configurationManager.setWorktreeConfig({
+                configEditor.setWorktreeConfig({
                     autoDirectory,
                     autoDirectoryPattern: pattern,
                     copySessionData,
@@ -104,9 +109,18 @@ const ConfigureWorktree = ({ onComplete }) => {
             React.createElement(Box, { marginTop: 1 },
                 React.createElement(Text, { dimColor: true }, "Press Enter to save or Escape to cancel"))));
     }
+    const scopeLabel = scope === 'project' ? 'Project' : 'Global';
     return (React.createElement(Box, { flexDirection: "column" },
         React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Text, { bold: true, color: "green" }, "Configure Worktree Settings")),
+            React.createElement(Text, { bold: true, color: "green" },
+                "Configure Worktree Settings (",
+                scopeLabel,
+                ")")),
+        isInheriting && (React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { backgroundColor: "cyan", color: "black" },
+                ' ',
+                "\uD83D\uDCCB Inheriting from global configuration",
+                ' '))),
         React.createElement(Box, { marginBottom: 1 },
             React.createElement(Text, { dimColor: true }, "Configure worktree creation settings")),
         autoDirectory && (React.createElement(Box, { marginBottom: 1 },

package/dist/components/ConfigureWorktreeHooks.js

@@ -2,13 +2,19 @@ import React, { useState } from 'react';
 import { Box, Text, useInput } from 'ink';
 import TextInputWrapper from './TextInputWrapper.js';
 import SelectInput from 'ink-select-input';
-import { configurationManager } from '../services/configurationManager.js';
+import { useConfigEditor } from '../contexts/ConfigEditorContext.js';
 const ConfigureWorktreeHooks = ({ onComplete, }) => {
+    const configEditor = useConfigEditor();
+    const scope = configEditor.getScope();
     const [view, setView] = useState('menu');
-    const [worktreeHooks, setWorktreeHooks] = useState(configurationManager.getWorktreeHooks());
+    // Get initial worktree hooks based on scope
+    const initialWorktreeHooks = configEditor.getWorktreeHooks() ?? {};
+    const [worktreeHooks, setWorktreeHooks] = useState(initialWorktreeHooks);
     const [currentCommand, setCurrentCommand] = useState('');
     const [currentEnabled, setCurrentEnabled] = useState(false);
     const [showSaveMessage, setShowSaveMessage] = useState(false);
+    // Show if inheriting from global (for project scope)
+    const isInheriting = scope === 'project' && !configEditor.hasProjectOverride('worktreeHooks');
     useInput((input, key) => {
         if (key.escape) {
             if (view === 'edit') {
@@ -48,7 +54,7 @@ const ConfigureWorktreeHooks = ({ onComplete, }) => {
     };
     const handleMenuSelect = (item) => {
         if (item.value === 'save') {
-            configurationManager.setWorktreeHooks(worktreeHooks);
+            configEditor.setWorktreeHooks(worktreeHooks);
             setShowSaveMessage(true);
             setTimeout(() => {
                 onComplete();
@@ -102,9 +108,18 @@ const ConfigureWorktreeHooks = ({ onComplete, }) => {
             React.createElement(Box, { marginTop: 1 },
                 React.createElement(Text, { dimColor: true }, "Press Enter to save, Tab to toggle enabled, Esc to cancel"))));
     }
+    const scopeLabel = scope === 'project' ? 'Project' : 'Global';
     return (React.createElement(Box, { flexDirection: "column" },
         React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Text, { bold: true, color: "green" }, "Configure Worktree Hooks")),
+            React.createElement(Text, { bold: true, color: "green" },
+                "Configure Worktree Hooks (",
+                scopeLabel,
+                ")")),
+        isInheriting && (React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { backgroundColor: "cyan", color: "black" },
+                ' ',
+                "\uD83D\uDCCB Inheriting from global configuration",
+                ' '))),
         React.createElement(Box, { marginBottom: 1 },
             React.createElement(Text, { dimColor: true }, "Set commands to run on worktree events:")),
         React.createElement(SelectInput, { items: getMenuItems(), onSelect: handleMenuSelect, isFocused: true, limit: 10 }),

package/dist/components/ConfigureWorktreeHooks.test.js

@@ -2,7 +2,7 @@ import React from 'react';
 import { render } from 'ink-testing-library';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import ConfigureWorktreeHooks from './ConfigureWorktreeHooks.js';
-import { configurationManager } from '../services/configurationManager.js';
+import { ConfigEditorProvider } from '../contexts/ConfigEditorContext.js';
 // Mock ink to avoid stdin issues
 vi.mock('ink', async () => {
     const actual = await vi.importActual('ink');
@@ -21,40 +21,75 @@ vi.mock('ink-select-input', async () => {
         },
     };
 });
-vi.mock('../services/configurationManager.js', () => ({
-    configurationManager: {
-        getWorktreeHooks: vi.fn(),
-        setWorktreeHooks: vi.fn(),
-    },
-}));
-const mockedConfigurationManager = configurationManager;
+// Create mock functions that will be used by the mock class
+const mockFns = {
+    getWorktreeHooks: vi.fn(),
+    setWorktreeHooks: vi.fn(),
+    hasProjectOverride: vi.fn().mockReturnValue(false),
+    getScope: vi.fn().mockReturnValue('global'),
+};
+vi.mock('../services/config/configEditor.js', () => {
+    return {
+        ConfigEditor: class {
+            constructor() {
+                Object.defineProperty(this, "getWorktreeHooks", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: mockFns.getWorktreeHooks
+                });
+                Object.defineProperty(this, "setWorktreeHooks", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: mockFns.setWorktreeHooks
+                });
+                Object.defineProperty(this, "hasProjectOverride", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: mockFns.hasProjectOverride
+                });
+                Object.defineProperty(this, "getScope", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: mockFns.getScope
+                });
+            }
+        },
+    };
+});
 describe('ConfigureWorktreeHooks', () => {
     beforeEach(() => {
         vi.clearAllMocks();
     });
     it('should render worktree hooks configuration screen', () => {
-        mockedConfigurationManager.getWorktreeHooks.mockReturnValue({});
+        mockFns.getWorktreeHooks.mockReturnValue({});
         const onComplete = vi.fn();
-        const { lastFrame } = render(React.createElement(ConfigureWorktreeHooks, { onComplete: onComplete }));
+        const { lastFrame } = render(React.createElement(ConfigEditorProvider, { scope: "global" },
+            React.createElement(ConfigureWorktreeHooks, { onComplete: onComplete })));
         expect(lastFrame()).toContain('Configure Worktree Hooks');
         expect(lastFrame()).toContain('Set commands to run on worktree events');
         expect(lastFrame()).toContain('Post Creation:');
     });
     it('should display configured hooks', () => {
-        mockedConfigurationManager.getWorktreeHooks.mockReturnValue({
+        mockFns.getWorktreeHooks.mockReturnValue({
             post_creation: {
                 command: 'npm install',
                 enabled: true,
             },
         });
         const onComplete = vi.fn();
-        const { lastFrame } = render(React.createElement(ConfigureWorktreeHooks, { onComplete: onComplete }));
+        const { lastFrame } = render(React.createElement(ConfigEditorProvider, { scope: "global" },
+            React.createElement(ConfigureWorktreeHooks, { onComplete: onComplete })));
         expect(lastFrame()).toContain('Post Creation: ✓ npm install');
     });
     it('should display not set when no hook configured', () => {
-        mockedConfigurationManager.getWorktreeHooks.mockReturnValue({});
+        mockFns.getWorktreeHooks.mockReturnValue({});
         const onComplete = vi.fn();
-        const { lastFrame } = render(React.createElement(ConfigureWorktreeHooks, { onComplete: onComplete }));
+        const { lastFrame } = render(React.createElement(ConfigEditorProvider, { scope: "global" },
+            React.createElement(ConfigureWorktreeHooks, { onComplete: onComplete })));
         expect(lastFrame()).toContain('Post Creation: ✗ (not set)');
     });
 });

package/dist/components/Menu.js

@@ -10,7 +10,7 @@ import { projectManager } from '../services/projectManager.js';
 import TextInputWrapper from './TextInputWrapper.js';
 import { useSearchMode } from '../hooks/useSearchMode.js';
 import { globalSessionOrchestrator } from '../services/globalSessionOrchestrator.js';
-import { configurationManager } from '../services/configurationManager.js';
+import { configReader } from '../services/config/configReader.js';
 const createSeparatorWithText = (text, totalWidth = 35) => {
     const textWithSpaces = ` ${text} `;
     const textLength = textWithSpaces.length;
@@ -36,7 +36,7 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
     const [recentProjects, setRecentProjects] = useState([]);
     const limit = 10;
     // Get worktree configuration for sorting
-    const worktreeConfig = configurationManager.getWorktreeConfig();
+    const worktreeConfig = configReader.getWorktreeConfig();
     // Use the search mode hook
     const { isSearchMode, searchQuery, selectedIndex, setSearchQuery } = useSearchMode(items.length, {
         isDisabled: !!error || !!loadError,
@@ -207,12 +207,29 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
                     label: `D ${MENU_ICONS.DELETE_WORKTREE} Delete Worktree`,
                     value: 'delete-worktree',
                 },
-                {
+            ];
+            // Add configuration menu items based on multiProject mode
+            if (multiProject) {
+                // In multi-project mode, only show global configuration (backward compatible)
+                otherMenuItems.push({
                     type: 'common',
                     label: `C ${MENU_ICONS.CONFIGURE_SHORTCUTS} Configuration`,
                     value: 'configuration',
-                },
-            ];
+                });
+            }
+            else {
+                // In single-project mode, show both Project and Global configuration
+                otherMenuItems.push({
+                    type: 'common',
+                    label: `P ${MENU_ICONS.CONFIGURE_SHORTCUTS} Project Configuration`,
+                    value: 'configuration-project',
+                });
+                otherMenuItems.push({
+                    type: 'common',
+                    label: `C ${MENU_ICONS.CONFIGURE_SHORTCUTS} Global Configuration`,
+                    value: 'configuration-global',
+                });
+            }
             menuItems.push(...otherMenuItems);
             if (projectName) {
                 // In multi-project mode, show 'Back to project list'
@@ -313,14 +330,37 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
                     hasSession: false,
                 });
                 break;
+            case 'p':
+                // Trigger project configuration action (only in single-project mode)
+                if (!multiProject) {
+                    onSelectWorktree({
+                        path: 'CONFIGURATION_PROJECT',
+                        branch: '',
+                        isMainWorktree: false,
+                        hasSession: false,
+                    });
+                }
+                break;
             case 'c':
                 // Trigger configuration action
-                onSelectWorktree({
-                    path: 'CONFIGURATION',
-                    branch: '',
-                    isMainWorktree: false,
-                    hasSession: false,
-                });
+                if (multiProject) {
+                    // In multi-project mode, 'c' opens global configuration (backward compatible)
+                    onSelectWorktree({
+                        path: 'CONFIGURATION',
+                        branch: '',
+                        isMainWorktree: false,
+                        hasSession: false,
+                    });
+                }
+                else {
+                    // In single-project mode, 'c' opens global configuration
+                    onSelectWorktree({
+                        path: 'CONFIGURATION_GLOBAL',
+                        branch: '',
+                        isMainWorktree: false,
+                        hasSession: false,
+                    });
+                }
                 break;
             case 'b':
                 // In multi-project mode, go back to project list
@@ -391,7 +431,7 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
             });
         }
         else if (item.value === 'configuration') {
-            // Handle in parent component - use special marker
+            // Handle in parent component - use special marker (backward compatible for multi-project mode)
             onSelectWorktree({
                 path: 'CONFIGURATION',
                 branch: '',
@@ -399,6 +439,24 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
                 hasSession: false,
             });
         }
+        else if (item.value === 'configuration-project') {
+            // Handle in parent component - use special marker for project config
+            onSelectWorktree({
+                path: 'CONFIGURATION_PROJECT',
+                branch: '',
+                isMainWorktree: false,
+                hasSession: false,
+            });
+        }
+        else if (item.value === 'configuration-global') {
+            // Handle in parent component - use special marker for global config
+            onSelectWorktree({
+                path: 'CONFIGURATION_GLOBAL',
+                branch: '',
+                isMainWorktree: false,
+                hasSession: false,
+            });
+        }
         else if (item.value === 'exit') {
             // Handle in parent component - use special marker
             onSelectWorktree({
@@ -459,7 +517,7 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
             React.createElement(Text, { dimColor: true }, isSearchMode
                 ? 'Search Mode: Type to filter, Enter to exit search, ESC to exit search'
                 : searchQuery
-                    ? `Filtered: "${searchQuery}" | ↑↓ Navigate Enter Select | /-Search ESC-Clear 0-9 Quick Select N-New M-Merge D-Delete C-Config ${projectName ? 'B-Back' : 'Q-Quit'}`
-                    : `Controls: ↑↓ Navigate Enter Select | Hotkeys: 0-9 Quick Select /-Search N-New M-Merge D-Delete C-Config ${projectName ? 'B-Back' : 'Q-Quit'}`))));
+                    ? `Filtered: "${searchQuery}" | ↑↓ Navigate Enter Select | /-Search ESC-Clear 0-9 Quick Select N-New M-Merge D-Delete ${multiProject ? 'C-Config' : 'P-ProjConfig C-GlobalConfig'} ${projectName ? 'B-Back' : 'Q-Quit'}`
+                    : `Controls: ↑↓ Navigate Enter Select | Hotkeys: 0-9 Quick Select /-Search N-New M-Merge D-Delete ${multiProject ? 'C-Config' : 'P-ProjConfig C-GlobalConfig'} ${projectName ? 'B-Back' : 'Q-Quit'}`))));
 };
 export default Menu;

package/dist/components/NewWorktree.js

@@ -3,13 +3,13 @@ import { Box, Text, useInput } from 'ink';
 import TextInputWrapper from './TextInputWrapper.js';
 import SelectInput from 'ink-select-input';
 import { shortcutManager } from '../services/shortcutManager.js';
-import { configurationManager } from '../services/configurationManager.js';
+import { configReader } from '../services/config/configReader.js';
 import { generateWorktreeDirectory } from '../utils/worktreeUtils.js';
 import { WorktreeService } from '../services/worktreeService.js';
 import { useSearchMode } from '../hooks/useSearchMode.js';
 import { Effect } from 'effect';
 const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
-    const worktreeConfig = configurationManager.getWorktreeConfig();
+    const worktreeConfig = configReader.getWorktreeConfig();
     const isAutoDirectory = worktreeConfig.autoDirectory;
     const limit = 10;
     // Adjust initial step based on auto directory mode

package/dist/components/NewWorktree.test.js

@@ -43,8 +43,8 @@ vi.mock('../services/shortcutManager.js', () => ({
         matchesShortcut: () => false,
     },
 }));
-vi.mock('../services/configurationManager.js', () => ({
-    configurationManager: {
+vi.mock('../services/config/configReader.js', () => ({
+    configReader: {
         getWorktreeConfig: () => ({
             autoDirectory: false,
             autoDirectoryPattern: '../{project}-{branch}',
@@ -175,9 +175,9 @@ describe('NewWorktree component Effect integration', () => {
     it('should handle empty branch list', async () => {
         const { Effect } = await import('effect');
         const { WorktreeService } = await import('../services/worktreeService.js');
-        const { configurationManager } = await import('../services/configurationManager.js');
+        const { configReader } = await import('../services/config/configReader.js');
         // Mock autoDirectory to true so component starts at base-branch step
-        vi.spyOn(configurationManager, 'getWorktreeConfig').mockReturnValue({
+        vi.spyOn(configReader, 'getWorktreeConfig').mockReturnValue({
             autoDirectory: true,
             autoDirectoryPattern: '../{project}-{branch}',
             copySessionData: true,
@@ -203,9 +203,9 @@ describe('NewWorktree component Effect integration', () => {
     it('should display branches after successful loading', async () => {
         const { Effect } = await import('effect');
         const { WorktreeService } = await import('../services/worktreeService.js');
-        const { configurationManager } = await import('../services/configurationManager.js');
+        const { configReader } = await import('../services/config/configReader.js');
         // Mock autoDirectory to true so component starts at base-branch step
-        vi.spyOn(configurationManager, 'getWorktreeConfig').mockReturnValue({
+        vi.spyOn(configReader, 'getWorktreeConfig').mockReturnValue({
             autoDirectory: true,
             autoDirectoryPattern: '../{project}-{branch}',
             copySessionData: true,

package/dist/components/PresetSelector.js

@@ -1,9 +1,9 @@
 import React, { useState } from 'react';
 import { Box, Text, useInput } from 'ink';
 import SelectInput from 'ink-select-input';
-import { configurationManager } from '../services/configurationManager.js';
+import { configReader } from '../services/config/configReader.js';
 const PresetSelector = ({ onSelect, onCancel, }) => {
-    const presetsConfig = configurationManager.getCommandPresets();
+    const presetsConfig = configReader.getCommandPresets();
     const [presets] = useState(presetsConfig.presets);
     const defaultPresetId = presetsConfig.defaultPresetId;
     const selectItems = presets.map(preset => {

package/dist/contexts/ConfigEditorContext.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import { ConfigEditor } from '../services/config/configEditor.js';
+import { ConfigScope } from '../types/index.js';
+declare const ConfigEditorContext: React.Context<ConfigEditor | null>;
+interface ConfigEditorProviderProps {
+    scope: ConfigScope;
+    children: React.ReactNode;
+}
+/**
+ * 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 declare function ConfigEditorProvider({ scope, children, }: ConfigEditorProviderProps): React.JSX.Element;
+/**
+ * Hook to access ConfigEditor from context.
+ * Must be used within a ConfigEditorProvider.
+ */
+export declare function useConfigEditor(): ConfigEditor;
+export { ConfigEditorContext };

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;