ccmanager 3.3.2 → 3.5.0

package/dist/services/worktreeService.sort.test.js

@@ -1,8 +1,9 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
 import { Effect } from 'effect';
-import { WorktreeService } from './worktreeService.js';
+import { WorktreeService, setWorktreeLastOpened } from './worktreeService.js';
 import { execSync } from 'child_process';
-import { configurationManager } from './configurationManager.js';
+// We need to keep a reference to the original Map to clear it between tests
+// Module-level state needs to be reset for isolated tests
 // Mock child_process module
 vi.mock('child_process');
 // Mock fs module
@@ -15,12 +16,9 @@ vi.mock('./worktreeConfigManager.js', () => ({
         reset: vi.fn(),
     },
 }));
-// Mock configurationManager
-vi.mock('./configurationManager.js', () => ({
-    configurationManager: {
-        getWorktreeLastOpenedTime: vi.fn(),
-        setWorktreeLastOpened: vi.fn(),
-        getWorktreeLastOpened: vi.fn(() => ({})),
+// Mock configReader (still needed for getWorktreeHooks in createWorktreeEffect)
+vi.mock('./config/configReader.js', () => ({
+    configReader: {
         getWorktreeConfig: vi.fn(() => ({
             autoDirectory: false,
             copySessionData: true,
@@ -35,7 +33,12 @@ vi.mock('../utils/hookExecutor.js', () => ({
 }));
 // Get the mocked functions with proper typing
 const mockedExecSync = vi.mocked(execSync);
-const mockedGetWorktreeLastOpenedTime = vi.mocked(configurationManager.getWorktreeLastOpenedTime);
+// Helper to clear worktree last opened state by setting all known paths to undefined time
+// Since we can't clear the Map directly, we'll set timestamps to 0 for cleanup
+const clearWorktreeTimestamps = () => {
+    // This is a workaround since we can't access the internal Map
+    // Tests should use unique paths or set their own timestamps
+};
 describe('WorktreeService - Sorting', () => {
     let service;
     beforeEach(() => {
@@ -50,6 +53,9 @@ describe('WorktreeService - Sorting', () => {
         // Create service instance
         service = new WorktreeService('/test/repo');
     });
+    afterEach(() => {
+        clearWorktreeTimestamps();
+    });
     describe('getWorktreesEffect with sortByLastSession', () => {
         it('should not sort worktrees when sortByLastSession is false', async () => {
             // Setup mock git output
@@ -104,15 +110,9 @@ branch refs/heads/feature-b
 `;
             mockedExecSync.mockReturnValue(gitOutput);
             // Setup timestamps - feature-b was opened most recently, then main, then feature-a
-            mockedGetWorktreeLastOpenedTime.mockImplementation((path) => {
-                if (path === '/test/repo')
-                    return 2000;
-                if (path === '/test/repo/feature-a')
-                    return 1000;
-                if (path === '/test/repo/feature-b')
-                    return 3000;
-                return undefined;
-            });
+            setWorktreeLastOpened('/test/repo', 2000);
+            setWorktreeLastOpened('/test/repo/feature-a', 1000);
+            setWorktreeLastOpened('/test/repo/feature-b', 3000);
             // Execute
             const result = await Effect.runPromise(service.getWorktreesEffect({ sortByLastSession: true }));
             // Verify sorted order (most recent first)
@@ -122,38 +122,33 @@ branch refs/heads/feature-b
             expect(result[2]?.path).toBe('/test/repo/feature-a'); // 1000
         });
         it('should place worktrees without timestamps at the end', async () => {
-            // Setup mock git output
-            const gitOutput = `worktree /test/repo
+            // Setup mock git output - use unique paths to avoid state pollution
+            const gitOutput = `worktree /test/repo-no-ts/main
 branch refs/heads/main
 
-worktree /test/repo/feature-a
+worktree /test/repo-no-ts/feature-a
 branch refs/heads/feature-a
 
-worktree /test/repo/feature-b
+worktree /test/repo-no-ts/feature-b
 branch refs/heads/feature-b
 
-worktree /test/repo/feature-c
+worktree /test/repo-no-ts/feature-c
 branch refs/heads/feature-c
 `;
             mockedExecSync.mockReturnValue(gitOutput);
             // Setup timestamps - only feature-a and feature-b have timestamps
-            mockedGetWorktreeLastOpenedTime.mockImplementation((path) => {
-                if (path === '/test/repo/feature-a')
-                    return 1000;
-                if (path === '/test/repo/feature-b')
-                    return 2000;
-                // main and feature-c have no timestamps (undefined)
-                return undefined;
-            });
+            // main and feature-c have no timestamps set
+            setWorktreeLastOpened('/test/repo-no-ts/feature-a', 1000);
+            setWorktreeLastOpened('/test/repo-no-ts/feature-b', 2000);
             // Execute
             const result = await Effect.runPromise(service.getWorktreesEffect({ sortByLastSession: true }));
             // Verify sorted order
             expect(result).toHaveLength(4);
-            expect(result[0]?.path).toBe('/test/repo/feature-b'); // 2000
-            expect(result[1]?.path).toBe('/test/repo/feature-a'); // 1000
+            expect(result[0]?.path).toBe('/test/repo-no-ts/feature-b'); // 2000
+            expect(result[1]?.path).toBe('/test/repo-no-ts/feature-a'); // 1000
             // main and feature-c at the end with timestamp 0 (original order preserved)
-            expect(result[2]?.path).toBe('/test/repo'); // 0
-            expect(result[3]?.path).toBe('/test/repo/feature-c'); // 0
+            expect(result[2]?.path).toBe('/test/repo-no-ts/main'); // undefined -> 0
+            expect(result[3]?.path).toBe('/test/repo-no-ts/feature-c'); // undefined -> 0
         });
         it('should handle empty worktree list', async () => {
             // Setup empty git output
@@ -164,158 +159,159 @@ branch refs/heads/feature-c
             expect(result).toHaveLength(0);
         });
         it('should handle single worktree', async () => {
-            // Setup mock git output with single worktree
-            const gitOutput = `worktree /test/repo
+            // Setup mock git output with single worktree - unique path
+            const gitOutput = `worktree /test/repo-single
 branch refs/heads/main
 `;
             mockedExecSync.mockReturnValue(gitOutput);
-            mockedGetWorktreeLastOpenedTime.mockReturnValue(1000);
+            setWorktreeLastOpened('/test/repo-single', 1000);
             // Execute
             const result = await Effect.runPromise(service.getWorktreesEffect({ sortByLastSession: true }));
             // Verify single result
             expect(result).toHaveLength(1);
-            expect(result[0]?.path).toBe('/test/repo');
+            expect(result[0]?.path).toBe('/test/repo-single');
         });
         it('should maintain stable sort for worktrees with same timestamp', async () => {
-            // Setup mock git output
-            const gitOutput = `worktree /test/repo/feature-a
+            // Setup mock git output - unique paths
+            const gitOutput = `worktree /test/repo-stable/feature-a
 branch refs/heads/feature-a
 
-worktree /test/repo/feature-b
+worktree /test/repo-stable/feature-b
 branch refs/heads/feature-b
 
-worktree /test/repo/feature-c
+worktree /test/repo-stable/feature-c
 branch refs/heads/feature-c
 `;
             mockedExecSync.mockReturnValue(gitOutput);
             // All have the same timestamp
-            mockedGetWorktreeLastOpenedTime.mockReturnValue(1000);
+            setWorktreeLastOpened('/test/repo-stable/feature-a', 1000);
+            setWorktreeLastOpened('/test/repo-stable/feature-b', 1000);
+            setWorktreeLastOpened('/test/repo-stable/feature-c', 1000);
             // Execute
             const result = await Effect.runPromise(service.getWorktreesEffect({ sortByLastSession: true }));
             // Verify original order is maintained (stable sort)
             expect(result).toHaveLength(3);
-            expect(result[0]?.path).toBe('/test/repo/feature-a');
-            expect(result[1]?.path).toBe('/test/repo/feature-b');
-            expect(result[2]?.path).toBe('/test/repo/feature-c');
+            expect(result[0]?.path).toBe('/test/repo-stable/feature-a');
+            expect(result[1]?.path).toBe('/test/repo-stable/feature-b');
+            expect(result[2]?.path).toBe('/test/repo-stable/feature-c');
         });
         it('should sort correctly with mixed timestamps including zero', async () => {
-            // Setup mock git output
-            const gitOutput = `worktree /test/repo/zero-timestamp
+            // Setup mock git output - unique paths
+            const gitOutput = `worktree /test/repo-zero/zero-timestamp
 branch refs/heads/zero-timestamp
 
-worktree /test/repo/recent
+worktree /test/repo-zero/recent
 branch refs/heads/recent
 
-worktree /test/repo/older
+worktree /test/repo-zero/older
 branch refs/heads/older
 `;
             mockedExecSync.mockReturnValue(gitOutput);
             // Setup timestamps including explicit zero
-            mockedGetWorktreeLastOpenedTime.mockImplementation((path) => {
-                if (path === '/test/repo/zero-timestamp')
-                    return 0;
-                if (path === '/test/repo/recent')
-                    return 3000;
-                if (path === '/test/repo/older')
-                    return 1000;
-                return undefined;
-            });
+            setWorktreeLastOpened('/test/repo-zero/zero-timestamp', 0);
+            setWorktreeLastOpened('/test/repo-zero/recent', 3000);
+            setWorktreeLastOpened('/test/repo-zero/older', 1000);
             // Execute
             const result = await Effect.runPromise(service.getWorktreesEffect({ sortByLastSession: true }));
             // Verify sorted order
             expect(result).toHaveLength(3);
-            expect(result[0]?.path).toBe('/test/repo/recent'); // 3000
-            expect(result[1]?.path).toBe('/test/repo/older'); // 1000
-            expect(result[2]?.path).toBe('/test/repo/zero-timestamp'); // 0
+            expect(result[0]?.path).toBe('/test/repo-zero/recent'); // 3000
+            expect(result[1]?.path).toBe('/test/repo-zero/older'); // 1000
+            expect(result[2]?.path).toBe('/test/repo-zero/zero-timestamp'); // 0
         });
         it('should preserve worktree properties after sorting', async () => {
-            // Setup mock git output
-            const gitOutput = `worktree /test/repo
+            // Setup mock git output - unique paths
+            const gitOutput = `worktree /test/repo-props
 branch refs/heads/main
 bare
 
-worktree /test/repo/feature-a
+worktree /test/repo-props/feature-a
 branch refs/heads/feature-a
 `;
             mockedExecSync.mockReturnValue(gitOutput);
-            mockedGetWorktreeLastOpenedTime.mockImplementation((path) => {
-                if (path === '/test/repo')
-                    return 1000;
-                if (path === '/test/repo/feature-a')
-                    return 2000;
-                return undefined;
-            });
+            setWorktreeLastOpened('/test/repo-props', 1000);
+            setWorktreeLastOpened('/test/repo-props/feature-a', 2000);
             // Execute
             const result = await Effect.runPromise(service.getWorktreesEffect({ sortByLastSession: true }));
             // Verify properties are preserved
             expect(result).toHaveLength(2);
-            expect(result[0]?.path).toBe('/test/repo/feature-a');
+            expect(result[0]?.path).toBe('/test/repo-props/feature-a');
             expect(result[0]?.branch).toBe('feature-a');
             expect(result[0]?.isMainWorktree).toBe(false);
-            expect(result[1]?.path).toBe('/test/repo');
+            expect(result[1]?.path).toBe('/test/repo-props');
             expect(result[1]?.branch).toBe('main');
             expect(result[1]?.isMainWorktree).toBe(true);
         });
         it('should handle very large timestamps', async () => {
-            // Setup mock git output
-            const gitOutput = `worktree /test/repo/old
+            // Setup mock git output - unique paths
+            const gitOutput = `worktree /test/repo-large/old
 branch refs/heads/old
 
-worktree /test/repo/new
+worktree /test/repo-large/new
 branch refs/heads/new
 `;
             mockedExecSync.mockReturnValue(gitOutput);
             // Use actual Date.now() values
             const now = Date.now();
             const yesterday = now - 24 * 60 * 60 * 1000;
-            mockedGetWorktreeLastOpenedTime.mockImplementation((path) => {
-                if (path === '/test/repo/old')
-                    return yesterday;
-                if (path === '/test/repo/new')
-                    return now;
-                return undefined;
-            });
+            setWorktreeLastOpened('/test/repo-large/old', yesterday);
+            setWorktreeLastOpened('/test/repo-large/new', now);
             // Execute
             const result = await Effect.runPromise(service.getWorktreesEffect({ sortByLastSession: true }));
             // Verify sorted order
             expect(result).toHaveLength(2);
-            expect(result[0]?.path).toBe('/test/repo/new');
-            expect(result[1]?.path).toBe('/test/repo/old');
+            expect(result[0]?.path).toBe('/test/repo-large/new');
+            expect(result[1]?.path).toBe('/test/repo-large/old');
         });
     });
     describe('getWorktreesEffect error handling with sorting', () => {
-        it('should not call getWorktreeLastOpenedTime when sortByLastSession is false', async () => {
-            // Setup mock git output
-            const gitOutput = `worktree /test/repo
+        it('should sort correctly when sortByLastSession is true', async () => {
+            // Setup mock git output - unique paths
+            const gitOutput = `worktree /test/repo-sort
 branch refs/heads/main
+
+worktree /test/repo-sort/feature-a
+branch refs/heads/feature-a
+
+worktree /test/repo-sort/feature-b
+branch refs/heads/feature-b
 `;
             mockedExecSync.mockReturnValue(gitOutput);
-            // Execute
-            await Effect.runPromise(service.getWorktreesEffect({ sortByLastSession: false }));
-            // Verify getWorktreeLastOpenedTime was not called
-            expect(mockedGetWorktreeLastOpenedTime).not.toHaveBeenCalled();
+            // Set timestamps to verify sorting works
+            setWorktreeLastOpened('/test/repo-sort', 1000);
+            setWorktreeLastOpened('/test/repo-sort/feature-a', 3000);
+            setWorktreeLastOpened('/test/repo-sort/feature-b', 2000);
+            // Execute with sorting
+            const result = await Effect.runPromise(service.getWorktreesEffect({ sortByLastSession: true }));
+            // Verify sorting happened correctly (implicitly means getWorktreeLastOpenedTime was called)
+            expect(result).toHaveLength(3);
+            expect(result[0]?.path).toBe('/test/repo-sort/feature-a'); // 3000
+            expect(result[1]?.path).toBe('/test/repo-sort/feature-b'); // 2000
+            expect(result[2]?.path).toBe('/test/repo-sort'); // 1000
         });
-        it('should call getWorktreeLastOpenedTime for each worktree when sorting', async () => {
-            // Setup mock git output
-            const gitOutput = `worktree /test/repo
+        it('should not sort when sortByLastSession is false', async () => {
+            // Setup mock git output - unique paths
+            const gitOutput = `worktree /test/repo-nosort
 branch refs/heads/main
 
-worktree /test/repo/feature-a
+worktree /test/repo-nosort/feature-a
 branch refs/heads/feature-a
 
-worktree /test/repo/feature-b
+worktree /test/repo-nosort/feature-b
 branch refs/heads/feature-b
 `;
             mockedExecSync.mockReturnValue(gitOutput);
-            mockedGetWorktreeLastOpenedTime.mockReturnValue(1000);
-            // Execute
-            await Effect.runPromise(service.getWorktreesEffect({ sortByLastSession: true }));
-            // Verify getWorktreeLastOpenedTime was called for each worktree
-            // Note: May be called multiple times during sort comparisons
-            expect(mockedGetWorktreeLastOpenedTime).toHaveBeenCalled();
-            expect(mockedGetWorktreeLastOpenedTime).toHaveBeenCalledWith('/test/repo');
-            expect(mockedGetWorktreeLastOpenedTime).toHaveBeenCalledWith('/test/repo/feature-a');
-            expect(mockedGetWorktreeLastOpenedTime).toHaveBeenCalledWith('/test/repo/feature-b');
+            // Set timestamps that would cause reordering if sorting was applied
+            setWorktreeLastOpened('/test/repo-nosort', 1000);
+            setWorktreeLastOpened('/test/repo-nosort/feature-a', 3000);
+            setWorktreeLastOpened('/test/repo-nosort/feature-b', 2000);
+            // Execute without sorting
+            const result = await Effect.runPromise(service.getWorktreesEffect({ sortByLastSession: false }));
+            // Verify original order is preserved
+            expect(result).toHaveLength(3);
+            expect(result[0]?.path).toBe('/test/repo-nosort');
+            expect(result[1]?.path).toBe('/test/repo-nosort/feature-a');
+            expect(result[2]?.path).toBe('/test/repo-nosort/feature-b');
         });
     });
 });

package/dist/services/worktreeService.test.js

@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { WorktreeService } from './worktreeService.js';
 import { execSync } from 'child_process';
 import { existsSync, statSync } from 'fs';
-import { configurationManager } from './configurationManager.js';
+import { configReader } from './config/configReader.js';
 import { Effect } from 'effect';
 import { GitError } from '../types/errors.js';
 // Mock child_process module
@@ -17,9 +17,9 @@ vi.mock('./worktreeConfigManager.js', () => ({
         reset: vi.fn(),
     },
 }));
-// Mock configurationManager
-vi.mock('./configurationManager.js', () => ({
-    configurationManager: {
+// Mock configReader
+vi.mock('./config/configReader.js', () => ({
+    configReader: {
         getWorktreeHooks: vi.fn(),
     },
 }));
@@ -31,7 +31,7 @@ vi.mock('../utils/hookExecutor.js', () => ({
 const mockedExecSync = vi.mocked(execSync);
 const mockedExistsSync = vi.mocked(existsSync);
 const mockedStatSync = vi.mocked(statSync);
-const mockedGetWorktreeHooks = vi.mocked(configurationManager.getWorktreeHooks);
+const mockedGetWorktreeHooks = vi.mocked(configReader.getWorktreeHooks);
 describe('WorktreeService', () => {
     let service;
     beforeEach(() => {

package/dist/types/index.d.ts

@@ -2,6 +2,7 @@ import type { IPty } from '../services/bunTerminal.js';
 import type pkg from '@xterm/headless';
 import { GitStatus } from '../utils/gitStatus.js';
 import { Mutex, SessionStateData } from '../utils/mutex.js';
+import type { StateDetector } from '../services/stateDetector/types.js';
 export type Terminal = InstanceType<typeof pkg.Terminal>;
 export type SessionState = 'idle' | 'busy' | 'waiting_input' | 'pending_auto_approval';
 export type StateDetectionStrategy = 'claude' | 'gemini' | 'codex' | 'cursor' | 'github-copilot' | 'cline' | 'opencode';
@@ -24,7 +25,6 @@ export interface Session {
     terminal: Terminal;
     stateCheckInterval: NodeJS.Timeout | undefined;
     isPrimaryCommand: boolean;
-    commandConfig: CommandConfig | undefined;
     detectionStrategy: StateDetectionStrategy | undefined;
     devcontainerConfig: DevcontainerConfig | undefined;
     /**
@@ -33,6 +33,11 @@ export interface Session {
      * Contains: state, pendingState, pendingStateStart, autoApprovalFailed, autoApprovalReason, autoApprovalAbortController
      */
     stateMutex: Mutex<SessionStateData>;
+    /**
+     * State detector instance for this session.
+     * Created once during session initialization based on detectionStrategy.
+     */
+    stateDetector: StateDetector;
 }
 export interface AutoApprovalResponse {
     needsPermission: boolean;
@@ -79,11 +84,6 @@ export interface WorktreeConfig {
     copySessionData?: boolean;
     sortByLastSession?: boolean;
 }
-export interface CommandConfig {
-    command: string;
-    args?: string[];
-    fallbackArgs?: string[];
-}
 export interface CommandPreset {
     id: string;
     name: string;
@@ -106,7 +106,6 @@ export interface ConfigurationData {
     statusHooks?: StatusHookConfig;
     worktreeHooks?: WorktreeHookConfig;
     worktree?: WorktreeConfig;
-    command?: CommandConfig;
     commandPresets?: CommandPresetsConfig;
     autoApproval?: {
         enabled: boolean;
@@ -114,6 +113,47 @@ export interface ConfigurationData {
         timeout?: number;
     };
 }
+export type ConfigScope = 'project' | 'global';
+export interface AutoApprovalConfig {
+    enabled: boolean;
+    customCommand?: string;
+    timeout?: number;
+}
+export interface ProjectConfigurationData {
+    shortcuts?: ShortcutConfig;
+    statusHooks?: StatusHookConfig;
+    worktreeHooks?: WorktreeHookConfig;
+    worktree?: WorktreeConfig;
+    commandPresets?: CommandPresetsConfig;
+    autoApproval?: AutoApprovalConfig;
+}
+/**
+ * Common interface for configuration readers.
+ * Provides read-only access to configuration values.
+ * Implemented by ConfigReader, ConfigEditor, GlobalConfigManager, ProjectConfigManager.
+ */
+export interface IConfigReader {
+    getShortcuts(): ShortcutConfig | undefined;
+    getStatusHooks(): StatusHookConfig | undefined;
+    getWorktreeHooks(): WorktreeHookConfig | undefined;
+    getWorktreeConfig(): WorktreeConfig | undefined;
+    getCommandPresets(): CommandPresetsConfig | undefined;
+    getAutoApprovalConfig(): AutoApprovalConfig | undefined;
+    reload(): void;
+}
+/**
+ * Common interface for configuration editors.
+ * Extends IConfigReader with write capabilities.
+ * Implemented by ConfigEditor, GlobalConfigManager, ProjectConfigManager.
+ */
+export interface IConfigEditor extends IConfigReader {
+    setShortcuts(value: ShortcutConfig): void;
+    setStatusHooks(value: StatusHookConfig): void;
+    setWorktreeHooks(value: WorktreeHookConfig): void;
+    setWorktreeConfig(value: WorktreeConfig): void;
+    setCommandPresets(value: CommandPresetsConfig): void;
+    setAutoApprovalConfig(value: AutoApprovalConfig): void;
+}
 export interface GitProject {
     name: string;
     path: string;

package/dist/utils/gitUtils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Get the git repository root path from a given directory.
+ * For worktrees, this returns the main repository root (parent of .git).
+ *
+ * @param cwd - The directory to start searching from
+ * @returns The absolute path to the git repository root, or null if not in a git repo
+ */
+export declare function getGitRepositoryRoot(cwd: string): string | null;

package/dist/utils/gitUtils.js

@@ -0,0 +1,32 @@
+import path from 'path';
+import { execSync } from 'child_process';
+/**
+ * Get the git repository root path from a given directory.
+ * For worktrees, this returns the main repository root (parent of .git).
+ *
+ * @param cwd - The directory to start searching from
+ * @returns The absolute path to the git repository root, or null if not in a git repo
+ */
+export function getGitRepositoryRoot(cwd) {
+    try {
+        const gitCommonDir = execSync('git rev-parse --git-common-dir', {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        const absoluteGitCommonDir = path.isAbsolute(gitCommonDir)
+            ? gitCommonDir
+            : path.resolve(cwd, gitCommonDir);
+        // Handle worktree paths: if path contains .git/worktrees, find the real .git parent
+        if (absoluteGitCommonDir.includes('.git/worktrees')) {
+            const gitIndex = absoluteGitCommonDir.indexOf('.git');
+            const gitPath = absoluteGitCommonDir.substring(0, gitIndex + 4);
+            return path.dirname(gitPath);
+        }
+        // For regular .git directories, the parent is the repository root
+        return path.dirname(absoluteGitCommonDir);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/utils/hookExecutor.js

@@ -2,7 +2,7 @@ import { spawn } from 'child_process';
 import { Effect } from 'effect';
 import { ProcessError } from '../types/errors.js';
 import { WorktreeService } from '../services/worktreeService.js';
-import { configurationManager } from '../services/configurationManager.js';
+import { configReader } from '../services/config/configReader.js';
 /**
  * Execute a hook command with the provided environment variables using Effect
  *
@@ -106,7 +106,7 @@ export function executeWorktreePostCreationHook(command, worktree, gitRoot, base
  * Errors are caught and logged but do not break the main flow
  */
 export function executeStatusHook(oldState, newState, session) {
-    const statusHooks = configurationManager.getStatusHooks();
+    const statusHooks = configReader.getStatusHooks();
     const hook = statusHooks[newState];
     if (!hook || !hook.enabled || !hook.command) {
         return Effect.void;

package/dist/utils/hookExecutor.test.js

@@ -4,13 +4,14 @@ import { executeHook, executeWorktreePostCreationHook, executeStatusHook, } from
 import { mkdtemp, rm, readFile, realpath } from 'fs/promises';
 import { tmpdir } from 'os';
 import { join } from 'path';
-import { configurationManager } from '../services/configurationManager.js';
+import { configReader } from '../services/config/configReader.js';
 import { WorktreeService } from '../services/worktreeService.js';
 import { GitError } from '../types/errors.js';
 import { Mutex, createInitialSessionStateData } from './mutex.js';
-// Mock the configurationManager
-vi.mock('../services/configurationManager.js', () => ({
-    configurationManager: {
+import { createStateDetector } from '../services/stateDetector/index.js';
+// Mock the configReader
+vi.mock('../services/config/configReader.js', () => ({
+    configReader: {
         getStatusHooks: vi.fn(),
     },
 }));
@@ -269,12 +270,12 @@ describe('hookExecutor Integration Tests', () => {
                 outputHistory: [],
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
-                commandConfig: undefined,
                 detectionStrategy: 'claude',
                 devcontainerConfig: undefined,
                 lastActivity: new Date(),
                 isActive: true,
                 stateMutex: new Mutex(createInitialSessionStateData()),
+                stateDetector: createStateDetector('claude'),
             };
             // Mock WorktreeService to return a worktree with the tmpDir path
             vi.mocked(WorktreeService).mockImplementation(function () {
@@ -290,7 +291,7 @@ describe('hookExecutor Integration Tests', () => {
                 };
             });
             // Configure mock to return a hook that writes to a file with delay
-            vi.mocked(configurationManager.getStatusHooks).mockReturnValue({
+            vi.mocked(configReader.getStatusHooks).mockReturnValue({
                 busy: {
                     enabled: true,
                     command: `sleep 0.1 && echo "Hook executed" > "${outputFile}"`,
@@ -323,12 +324,12 @@ describe('hookExecutor Integration Tests', () => {
                 outputHistory: [],
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
-                commandConfig: undefined,
                 detectionStrategy: 'claude',
                 devcontainerConfig: undefined,
                 lastActivity: new Date(),
                 isActive: true,
                 stateMutex: new Mutex(createInitialSessionStateData()),
+                stateDetector: createStateDetector('claude'),
             };
             // Mock WorktreeService to return a worktree with the tmpDir path
             vi.mocked(WorktreeService).mockImplementation(function () {
@@ -344,7 +345,7 @@ describe('hookExecutor Integration Tests', () => {
                 };
             });
             // Configure mock to return a hook that fails
-            vi.mocked(configurationManager.getStatusHooks).mockReturnValue({
+            vi.mocked(configReader.getStatusHooks).mockReturnValue({
                 busy: {
                     enabled: true,
                     command: 'exit 1',
@@ -375,12 +376,12 @@ describe('hookExecutor Integration Tests', () => {
                 outputHistory: [],
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
-                commandConfig: undefined,
                 detectionStrategy: 'claude',
                 devcontainerConfig: undefined,
                 lastActivity: new Date(),
                 isActive: true,
                 stateMutex: new Mutex(createInitialSessionStateData()),
+                stateDetector: createStateDetector('claude'),
             };
             // Mock WorktreeService to return a worktree with the tmpDir path
             vi.mocked(WorktreeService).mockImplementation(function () {
@@ -396,7 +397,7 @@ describe('hookExecutor Integration Tests', () => {
                 };
             });
             // Configure mock to return a disabled hook
-            vi.mocked(configurationManager.getStatusHooks).mockReturnValue({
+            vi.mocked(configReader.getStatusHooks).mockReturnValue({
                 busy: {
                     enabled: false,
                     command: `echo "Should not run" > "${outputFile}"`,
@@ -429,12 +430,12 @@ describe('hookExecutor Integration Tests', () => {
                 outputHistory: [],
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
-                commandConfig: undefined,
                 detectionStrategy: 'claude',
                 devcontainerConfig: undefined,
                 lastActivity: new Date(),
                 isActive: true,
                 stateMutex: new Mutex(createInitialSessionStateData()),
+                stateDetector: createStateDetector('claude'),
             };
             // Mock WorktreeService to fail with GitError
             vi.mocked(WorktreeService).mockImplementation(function () {
@@ -447,7 +448,7 @@ describe('hookExecutor Integration Tests', () => {
                 };
             });
             // Configure mock to return a hook that should execute despite worktree query failure
-            vi.mocked(configurationManager.getStatusHooks).mockReturnValue({
+            vi.mocked(configReader.getStatusHooks).mockReturnValue({
                 busy: {
                     enabled: true,
                     command: `echo "Hook ran with branch: $CCMANAGER_WORKTREE_BRANCH" > "${outputFile}"`,