ccmanager 2.1.0 → 2.2.0

package/README.md

@@ -205,6 +205,24 @@ Status hooks allow you to:
 
 For detailed setup instructions, see [docs/state-hooks.md](docs/status-hooks.md).
 
+## Worktree Hooks
+
+Worktree hooks execute custom commands when worktrees are created, enabling automation of development environment setup.
+
+### Features
+- **Post-creation hook**: Run commands after a worktree is created
+- **Environment variables**: Access worktree path, branch name, and git root
+- **Non-blocking execution**: Hooks run asynchronously without delaying operations
+- **Error resilience**: Hook failures don't prevent worktree creation
+
+### Use Cases
+- Set up development dependencies (`npm install`, `bundle install`)
+- Configure IDE settings per branch
+- Send notifications when worktrees are created
+- Initialize branch-specific configurations
+
+For configuration and examples, see [docs/worktree-hooks.md](docs/worktree-hooks.md).
+
 ## Automatic Worktree Directory Generation
 
 CCManager can automatically generate worktree directory paths based on branch names, streamlining the worktree creation process.

package/dist/components/App.js

@@ -183,7 +183,7 @@ const App = ({ devcontainerConfig, multiProject }) => {
         setView('creating-worktree');
         setError(null);
         // Create the worktree
-        const result = worktreeService.createWorktree(path, branch, baseBranch, copySessionData, copyClaudeDirectory);
+        const result = await worktreeService.createWorktree(path, branch, baseBranch, copySessionData, copyClaudeDirectory);
         if (result.success) {
             // Success - return to menu
             handleReturnToMenu();

package/dist/components/Configuration.js

@@ -2,7 +2,8 @@ import React, { useState } from 'react';
 import { Box, Text, useInput } from 'ink';
 import SelectInput from 'ink-select-input';
 import ConfigureShortcuts from './ConfigureShortcuts.js';
-import ConfigureHooks from './ConfigureHooks.js';
+import ConfigureStatusHooks from './ConfigureStatusHooks.js';
+import ConfigureWorktreeHooks from './ConfigureWorktreeHooks.js';
 import ConfigureWorktree from './ConfigureWorktree.js';
 import ConfigureCommand from './ConfigureCommand.js';
 import { shortcutManager } from '../services/shortcutManager.js';
@@ -15,7 +16,11 @@ const Configuration = ({ onComplete }) => {
         },
         {
             label: 'H 🔧  Configure Status Hooks',
-            value: 'hooks',
+            value: 'statusHooks',
+        },
+        {
+            label: 'T 🔨  Configure Worktree Hooks',
+            value: 'worktreeHooks',
         },
         {
             label: 'W 📁  Configure Worktree Settings',
@@ -37,8 +42,11 @@ const Configuration = ({ onComplete }) => {
         else if (item.value === 'shortcuts') {
             setView('shortcuts');
         }
-        else if (item.value === 'hooks') {
-            setView('hooks');
+        else if (item.value === 'statusHooks') {
+            setView('statusHooks');
+        }
+        else if (item.value === 'worktreeHooks') {
+            setView('worktreeHooks');
         }
         else if (item.value === 'worktree') {
             setView('worktree');
@@ -60,7 +68,10 @@ const Configuration = ({ onComplete }) => {
                 setView('shortcuts');
                 break;
             case 'h':
-                setView('hooks');
+                setView('statusHooks');
+                break;
+            case 't':
+                setView('worktreeHooks');
                 break;
             case 'w':
                 setView('worktree');
@@ -80,8 +91,11 @@ const Configuration = ({ onComplete }) => {
     if (view === 'shortcuts') {
         return React.createElement(ConfigureShortcuts, { onComplete: handleSubMenuComplete });
     }
-    if (view === 'hooks') {
-        return React.createElement(ConfigureHooks, { onComplete: handleSubMenuComplete });
+    if (view === 'statusHooks') {
+        return React.createElement(ConfigureStatusHooks, { onComplete: handleSubMenuComplete });
+    }
+    if (view === 'worktreeHooks') {
+        return React.createElement(ConfigureWorktreeHooks, { onComplete: handleSubMenuComplete });
     }
     if (view === 'worktree') {
         return React.createElement(ConfigureWorktree, { onComplete: handleSubMenuComplete });

package/dist/components/ConfigureStatusHooks.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface ConfigureStatusHooksProps {
+    onComplete: () => void;
+}
+declare const ConfigureStatusHooks: React.FC<ConfigureStatusHooksProps>;
+export default ConfigureStatusHooks;

package/dist/components/{ConfigureHooks.js → ConfigureStatusHooks.js}

@@ -1,4 +1,4 @@
-import React, { useState, useEffect } from 'react';
+import React, { useState } from 'react';
 import { Box, Text, useInput } from 'ink';
 import TextInputWrapper from './TextInputWrapper.js';
 import SelectInput from 'ink-select-input';
@@ -8,16 +8,13 @@ const STATUS_LABELS = {
     busy: 'Busy',
     waiting_input: 'Waiting for Input',
 };
-const ConfigureHooks = ({ onComplete }) => {
+const ConfigureStatusHooks = ({ onComplete, }) => {
     const [view, setView] = useState('menu');
     const [selectedStatus, setSelectedStatus] = useState('idle');
-    const [hooks, setHooks] = useState({});
+    const [statusHooks, setStatusHooks] = useState(configurationManager.getStatusHooks());
     const [currentCommand, setCurrentCommand] = useState('');
     const [currentEnabled, setCurrentEnabled] = useState(false);
     const [showSaveMessage, setShowSaveMessage] = useState(false);
-    useEffect(() => {
-        setHooks(configurationManager.getStatusHooks());
-    }, []);
     useInput((input, key) => {
         if (key.escape) {
             if (view === 'edit') {
@@ -35,16 +32,16 @@ const ConfigureHooks = ({ onComplete }) => {
         const items = [];
         // Add status hook items
         ['idle', 'busy', 'waiting_input'].forEach(status => {
-            const hook = hooks[status];
+            const hook = statusHooks[status];
             const enabled = hook?.enabled ? '✓' : '✗';
             const command = hook?.command || '(not set)';
             items.push({
                 label: `${STATUS_LABELS[status]}: ${enabled} ${command}`,
-                value: status,
+                value: `status:${status}`,
             });
         });
         items.push({
-            label: '─────────────',
+            label: '',
             value: 'separator',
         });
         items.push({
@@ -59,7 +56,7 @@ const ConfigureHooks = ({ onComplete }) => {
     };
     const handleMenuSelect = (item) => {
         if (item.value === 'save') {
-            configurationManager.setStatusHooks(hooks);
+            configurationManager.setStatusHooks(statusHooks);
             setShowSaveMessage(true);
             setTimeout(() => {
                 onComplete();
@@ -68,17 +65,18 @@ const ConfigureHooks = ({ onComplete }) => {
         else if (item.value === 'cancel') {
             onComplete();
         }
-        else if (item.value !== 'separator') {
-            const status = item.value;
+        else if (!item.value.includes('separator') &&
+            item.value.startsWith('status:')) {
+            const status = item.value.split(':')[1];
             setSelectedStatus(status);
-            const hook = hooks[status];
+            const hook = statusHooks[status];
             setCurrentCommand(hook?.command || '');
-            setCurrentEnabled(hook?.enabled ?? true); // Default to true if not set
+            setCurrentEnabled(hook?.enabled ?? true);
             setView('edit');
         }
     };
     const handleCommandSubmit = (value) => {
-        setHooks(prev => ({
+        setStatusHooks(prev => ({
             ...prev,
             [selectedStatus]: {
                 command: value,
@@ -123,11 +121,11 @@ const ConfigureHooks = ({ onComplete }) => {
     }
     return (React.createElement(Box, { flexDirection: "column" },
         React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Text, { bold: true, color: "green" }, "Configure Status Change Hooks")),
+            React.createElement(Text, { bold: true, color: "green" }, "Configure Status Hooks")),
         React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Text, { dimColor: true }, "Set commands to run when Claude Code session status changes:")),
+            React.createElement(Text, { dimColor: true }, "Set commands to run when session status changes:")),
         React.createElement(SelectInput, { items: getMenuItems(), onSelect: handleMenuSelect, isFocused: true, limit: 10 }),
         React.createElement(Box, { marginTop: 1 },
             React.createElement(Text, { dimColor: true }, "Press Esc to go back"))));
 };
-export default ConfigureHooks;
+export default ConfigureStatusHooks;

package/dist/components/ConfigureStatusHooks.test.d.ts

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

package/dist/components/ConfigureStatusHooks.test.js

@@ -0,0 +1,62 @@
+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';
+// Mock ink to avoid stdin issues
+vi.mock('ink', async () => {
+    const actual = await vi.importActual('ink');
+    return {
+        ...actual,
+        useInput: vi.fn(),
+    };
+});
+// Mock SelectInput to render items as simple text
+vi.mock('ink-select-input', async () => {
+    const React = await vi.importActual('react');
+    const { Text, Box } = await vi.importActual('ink');
+    return {
+        default: ({ items }) => {
+            return React.createElement(Box, { flexDirection: 'column' }, items.map((item, index) => React.createElement(Text, { key: index }, item.label)));
+        },
+    };
+});
+vi.mock('../services/configurationManager.js', () => ({
+    configurationManager: {
+        getStatusHooks: vi.fn(),
+        setStatusHooks: vi.fn(),
+    },
+}));
+const mockedConfigurationManager = configurationManager;
+describe('ConfigureStatusHooks', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should render status hooks configuration screen', () => {
+        mockedConfigurationManager.getStatusHooks.mockReturnValue({});
+        const onComplete = vi.fn();
+        const { lastFrame } = render(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:');
+        expect(lastFrame()).toContain('Busy:');
+        expect(lastFrame()).toContain('Waiting for Input:');
+    });
+    it('should display configured hooks', () => {
+        mockedConfigurationManager.getStatusHooks.mockReturnValue({
+            idle: {
+                command: 'notify-send "Idle"',
+                enabled: true,
+            },
+            busy: {
+                command: 'echo "Busy"',
+                enabled: false,
+            },
+        });
+        const onComplete = vi.fn();
+        const { lastFrame } = render(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/ConfigureWorktreeHooks.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface ConfigureWorktreeHooksProps {
+    onComplete: () => void;
+}
+declare const ConfigureWorktreeHooks: React.FC<ConfigureWorktreeHooksProps>;
+export default ConfigureWorktreeHooks;

package/dist/components/ConfigureWorktreeHooks.js

@@ -0,0 +1,114 @@
+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';
+const ConfigureWorktreeHooks = ({ onComplete, }) => {
+    const [view, setView] = useState('menu');
+    const [worktreeHooks, setWorktreeHooks] = useState(configurationManager.getWorktreeHooks());
+    const [currentCommand, setCurrentCommand] = useState('');
+    const [currentEnabled, setCurrentEnabled] = useState(false);
+    const [showSaveMessage, setShowSaveMessage] = useState(false);
+    useInput((input, key) => {
+        if (key.escape) {
+            if (view === 'edit') {
+                setView('menu');
+            }
+            else {
+                onComplete();
+            }
+        }
+        else if (key.tab && view === 'edit') {
+            toggleEnabled();
+        }
+    });
+    const getMenuItems = () => {
+        const items = [];
+        // Add worktree hook items
+        const postCreationHook = worktreeHooks.post_creation;
+        const postCreationEnabled = postCreationHook?.enabled ? '✓' : '✗';
+        const postCreationCommand = postCreationHook?.command || '(not set)';
+        items.push({
+            label: `Post Creation: ${postCreationEnabled} ${postCreationCommand}`,
+            value: 'worktree:post_creation',
+        });
+        items.push({
+            label: '',
+            value: 'separator',
+        });
+        items.push({
+            label: '💾 Save and Return',
+            value: 'save',
+        });
+        items.push({
+            label: '← Cancel',
+            value: 'cancel',
+        });
+        return items;
+    };
+    const handleMenuSelect = (item) => {
+        if (item.value === 'save') {
+            configurationManager.setWorktreeHooks(worktreeHooks);
+            setShowSaveMessage(true);
+            setTimeout(() => {
+                onComplete();
+            }, 1000);
+        }
+        else if (item.value === 'cancel') {
+            onComplete();
+        }
+        else if (!item.value.includes('separator') &&
+            item.value === 'worktree:post_creation') {
+            const hook = worktreeHooks.post_creation;
+            setCurrentCommand(hook?.command || '');
+            setCurrentEnabled(hook?.enabled ?? true);
+            setView('edit');
+        }
+    };
+    const handleCommandSubmit = (value) => {
+        setWorktreeHooks(prev => ({
+            ...prev,
+            post_creation: {
+                command: value,
+                enabled: currentEnabled,
+            },
+        }));
+        setView('menu');
+    };
+    const toggleEnabled = () => {
+        setCurrentEnabled(prev => !prev);
+    };
+    if (showSaveMessage) {
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { color: "green" }, "\u2713 Configuration saved successfully!")));
+    }
+    if (view === 'edit') {
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { bold: true, color: "green" }, "Configure Post Worktree Creation Hook")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null, "Command to execute after creating a new worktree:")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(TextInputWrapper, { value: currentCommand, onChange: setCurrentCommand, onSubmit: handleCommandSubmit, placeholder: "Enter command (e.g., npm install && npm run build)" })),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null,
+                    "Enabled: ",
+                    currentEnabled ? '✓' : '✗',
+                    " (Press Tab to toggle)")),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "Environment variables available: CCMANAGER_WORKTREE, CCMANAGER_WORKTREE_BRANCH,")),
+            React.createElement(Box, null,
+                React.createElement(Text, { dimColor: true }, "CCMANAGER_BASE_BRANCH, CCMANAGER_GIT_ROOT")),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "Press Enter to save, Tab to toggle enabled, Esc to cancel"))));
+    }
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "green" }, "Configure Worktree Hooks")),
+        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 }),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true }, "Press Esc to go back"))));
+};
+export default ConfigureWorktreeHooks;

package/dist/components/ConfigureWorktreeHooks.test.d.ts

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

package/dist/components/ConfigureWorktreeHooks.test.js

@@ -0,0 +1,60 @@
+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';
+// Mock ink to avoid stdin issues
+vi.mock('ink', async () => {
+    const actual = await vi.importActual('ink');
+    return {
+        ...actual,
+        useInput: vi.fn(),
+    };
+});
+// Mock SelectInput to render items as simple text
+vi.mock('ink-select-input', async () => {
+    const React = await vi.importActual('react');
+    const { Text, Box } = await vi.importActual('ink');
+    return {
+        default: ({ items }) => {
+            return React.createElement(Box, { flexDirection: 'column' }, items.map((item, index) => React.createElement(Text, { key: index }, item.label)));
+        },
+    };
+});
+vi.mock('../services/configurationManager.js', () => ({
+    configurationManager: {
+        getWorktreeHooks: vi.fn(),
+        setWorktreeHooks: vi.fn(),
+    },
+}));
+const mockedConfigurationManager = configurationManager;
+describe('ConfigureWorktreeHooks', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should render worktree hooks configuration screen', () => {
+        mockedConfigurationManager.getWorktreeHooks.mockReturnValue({});
+        const onComplete = vi.fn();
+        const { lastFrame } = render(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({
+            post_creation: {
+                command: 'npm install',
+                enabled: true,
+            },
+        });
+        const onComplete = vi.fn();
+        const { lastFrame } = render(React.createElement(ConfigureWorktreeHooks, { onComplete: onComplete }));
+        expect(lastFrame()).toContain('Post Creation: ✓ npm install');
+    });
+    it('should display not set when no hook configured', () => {
+        mockedConfigurationManager.getWorktreeHooks.mockReturnValue({});
+        const onComplete = vi.fn();
+        const { lastFrame } = render(React.createElement(ConfigureWorktreeHooks, { onComplete: onComplete }));
+        expect(lastFrame()).toContain('Post Creation: ✗ (not set)');
+    });
+});

package/dist/services/configurationManager.d.ts

@@ -1,4 +1,4 @@
-import { ConfigurationData, StatusHookConfig, ShortcutConfig, WorktreeConfig, CommandConfig, CommandPreset, CommandPresetsConfig } from '../types/index.js';
+import { ConfigurationData, StatusHookConfig, WorktreeHookConfig, ShortcutConfig, WorktreeConfig, CommandConfig, CommandPreset, CommandPresetsConfig } from '../types/index.js';
 export declare class ConfigurationManager {
     private configPath;
     private legacyShortcutsPath;
@@ -12,6 +12,8 @@ export declare class ConfigurationManager {
     setShortcuts(shortcuts: ShortcutConfig): void;
     getStatusHooks(): StatusHookConfig;
     setStatusHooks(hooks: StatusHookConfig): void;
+    getWorktreeHooks(): WorktreeHookConfig;
+    setWorktreeHooks(hooks: WorktreeHookConfig): void;
     getConfiguration(): ConfigurationData;
     setConfiguration(config: ConfigurationData): void;
     getWorktreeConfig(): WorktreeConfig;

package/dist/services/configurationManager.js

@@ -70,6 +70,9 @@ export class ConfigurationManager {
         if (!this.config.statusHooks) {
             this.config.statusHooks = {};
         }
+        if (!this.config.worktreeHooks) {
+            this.config.worktreeHooks = {};
+        }
         if (!this.config.worktree) {
             this.config.worktree = {
                 autoDirectory: false,
@@ -127,6 +130,13 @@ export class ConfigurationManager {
         this.config.statusHooks = hooks;
         this.saveConfig();
     }
+    getWorktreeHooks() {
+        return this.config.worktreeHooks || {};
+    }
+    setWorktreeHooks(hooks) {
+        this.config.worktreeHooks = hooks;
+        this.saveConfig();
+    }
     getConfiguration() {
         return this.config;
     }

package/dist/services/projectManager.test.js

@@ -1,16 +1,17 @@
 import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
-import { ProjectManager } from './projectManager.js';
-import { ENV_VARS } from '../constants/env.js';
 import * as fs from 'fs';
 import * as path from 'path';
-import * as os from 'os';
-// Mock fs module
+// Mock modules before any other imports that might use them
 vi.mock('fs');
-vi.mock('os');
+vi.mock('os', () => ({
+    homedir: vi.fn(() => '/home/user'),
+    platform: vi.fn(() => 'linux'),
+}));
+// Now import modules that depend on the mocked modules
+import { ProjectManager } from './projectManager.js';
+import { ENV_VARS } from '../constants/env.js';
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const mockFs = fs;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const mockOs = os;
 describe('ProjectManager', () => {
     let projectManager;
     const mockProjectsDir = '/home/user/projects';
@@ -20,8 +21,6 @@ describe('ProjectManager', () => {
         vi.clearAllMocks();
         // Reset environment variables
         delete process.env[ENV_VARS.MULTI_PROJECT_ROOT];
-        // Mock os.homedir
-        mockOs.homedir.mockReturnValue('/home/user');
         // Mock fs methods for config directory
         mockFs.existsSync.mockImplementation((path) => {
             if (path === mockConfigDir)

package/dist/services/sessionManager.d.ts

@@ -32,7 +32,6 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     setSessionActive(worktreePath: string, active: boolean): void;
     destroySession(worktreePath: string): void;
     getAllSessions(): Session[];
-    private executeStatusHook;
     createSessionWithDevcontainer(worktreePath: string, devcontainerConfig: DevcontainerConfig, presetId?: string): Promise<Session>;
     destroy(): void;
     static getSessionCounts(sessions: Session[]): SessionCounts;

package/dist/services/sessionManager.js

@@ -4,7 +4,7 @@ import pkg from '@xterm/headless';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import { configurationManager } from './configurationManager.js';
-import { WorktreeService } from './worktreeService.js';
+import { executeStatusHook } from '../utils/hookExecutor.js';
 import { createStateDetector } from './stateDetector.js';
 const { Terminal } = pkg;
 const execAsync = promisify(exec);
@@ -188,13 +188,13 @@ export class SessionManager extends EventEmitter {
     setupBackgroundHandler(session) {
         // Setup data handler
         this.setupDataHandler(session);
-        // Set up interval-based state detection
         session.stateCheckInterval = setInterval(() => {
             const oldState = session.state;
             const newState = this.detectTerminalState(session);
             if (newState !== oldState) {
                 session.state = newState;
-                this.executeStatusHook(oldState, newState, session);
+                // Execute status hook asynchronously (non-blocking)
+                void executeStatusHook(oldState, newState, session);
                 this.emit('sessionStateChanged', session);
             }
         }, 100); // Check every 100ms
@@ -252,36 +252,6 @@ export class SessionManager extends EventEmitter {
     getAllSessions() {
         return Array.from(this.sessions.values());
     }
-    executeStatusHook(oldState, newState, session) {
-        const statusHooks = configurationManager.getStatusHooks();
-        const hook = statusHooks[newState];
-        if (hook && hook.enabled && hook.command) {
-            // Get branch information
-            const worktreeService = new WorktreeService();
-            const worktrees = worktreeService.getWorktrees();
-            const worktree = worktrees.find(wt => wt.path === session.worktreePath);
-            const branch = worktree?.branch || 'unknown';
-            // Execute the hook command in the session's worktree directory
-            exec(hook.command, {
-                cwd: session.worktreePath,
-                env: {
-                    ...process.env,
-                    CCMANAGER_OLD_STATE: oldState,
-                    CCMANAGER_NEW_STATE: newState,
-                    CCMANAGER_WORKTREE: session.worktreePath,
-                    CCMANAGER_WORKTREE_BRANCH: branch,
-                    CCMANAGER_SESSION_ID: session.id,
-                },
-            }, (error, _stdout, stderr) => {
-                if (error) {
-                    console.error(`Failed to execute ${newState} hook: ${error.message}`);
-                }
-                if (stderr) {
-                    console.error(`Hook stderr: ${stderr}`);
-                }
-            });
-        }
-    }
     async createSessionWithDevcontainer(worktreePath, devcontainerConfig, presetId) {
         // Check if session already exists
         const existing = this.sessions.get(worktreePath);

package/dist/services/worktreeService.d.ts

@@ -10,10 +10,10 @@ export declare class WorktreeService {
     getGitRootPath(): string;
     getDefaultBranch(): string;
     getAllBranches(): string[];
-    createWorktree(worktreePath: string, branch: string, baseBranch: string, copySessionData?: boolean, copyClaudeDirectory?: boolean): {
+    createWorktree(worktreePath: string, branch: string, baseBranch: string, copySessionData?: boolean, copyClaudeDirectory?: boolean): Promise<{
         success: boolean;
         error?: string;
-    };
+    }>;
     deleteWorktree(worktreePath: string, options?: {
         deleteBranch?: boolean;
     }): {

package/dist/services/worktreeService.js

@@ -3,6 +3,8 @@ import { existsSync, statSync, cpSync } from 'fs';
 import path from 'path';
 import { setWorktreeParentBranch } from '../utils/worktreeConfig.js';
 import { getClaudeProjectsDir, pathToClaudeProjectName, } from '../utils/claudeDir.js';
+import { executeWorktreePostCreationHook } from '../utils/hookExecutor.js';
+import { configurationManager } from './configurationManager.js';
 const CLAUDE_DIR = '.claude';
 export class WorktreeService {
     constructor(rootPath) {
@@ -188,7 +190,7 @@ export class WorktreeService {
             return [];
         }
     }
-    createWorktree(worktreePath, branch, baseBranch, copySessionData = false, copyClaudeDirectory = false) {
+    async createWorktree(worktreePath, branch, baseBranch, copySessionData = false, copyClaudeDirectory = false) {
         try {
             // Resolve the worktree path relative to the git repository root
             const resolvedPath = path.isAbsolute(worktreePath)
@@ -239,6 +241,21 @@ export class WorktreeService {
                     console.error('Warning: Failed to copy .claude directory:', error);
                 }
             }
+            // Execute post-creation hook if configured
+            const worktreeHooks = configurationManager.getWorktreeHooks();
+            if (worktreeHooks.post_creation?.enabled &&
+                worktreeHooks.post_creation?.command) {
+                // Create a worktree object for the hook
+                const newWorktree = {
+                    path: resolvedPath,
+                    branch: branch,
+                    isMainWorktree: false,
+                    hasSession: false,
+                };
+                // Execute the hook synchronously (blocking)
+                // Wait for the hook to complete before returning
+                await executeWorktreePostCreationHook(worktreeHooks.post_creation.command, newWorktree, this.gitRootPath, baseBranch);
+            }
             return { success: true };
         }
         catch (error) {