ccmanager 1.3.0 → 1.4.0

package/README.md

@@ -15,6 +15,7 @@ https://github.com/user-attachments/assets/15914a88-e288-4ac9-94d5-8127f2e19dbf
 - Switch between sessions seamlessly
 - Visual status indicators for session states (busy, waiting, idle)
 - Create, merge, and delete worktrees from within the app
+- **Copy Claude Code session data** between worktrees to maintain conversation context
 - Configurable keyboard shortcuts
 - Command presets with automatic fallback support
 - Configurable state detection strategies for different CLI tools
@@ -154,6 +155,41 @@ CCManager supports configuring the command and arguments used to run Claude Code
 For detailed configuration options and examples, see [docs/command-config.md](docs/command-config.md).
 
 
+## Session Data Copying
+
+CCManager can copy Claude Code session data (conversation history, context, and project state) when creating new worktrees, allowing you to maintain context across different branches.
+
+### Features
+
+- **Seamless Context Transfer**: Continue conversations in new worktrees without losing context
+- **Configurable Default**: Set whether to copy session data by default
+- **Per-Creation Choice**: Decide on each worktree creation whether to copy data
+- **Safe Operation**: Copying is non-fatal - worktree creation succeeds even if copying fails
+
+### How It Works
+
+When creating a new worktree, CCManager:
+1. Asks whether to copy session data from the current worktree
+2. Copies all session files from `~/.claude/projects/[source-path]` to `~/.claude/projects/[target-path]`
+3. Preserves conversation history, project context, and Claude Code state
+4. Allows immediate continuation of conversations in the new worktree
+
+### Configuration
+
+1. Navigate to **Configuration** → **Configure Worktree**
+2. Toggle **Copy Session Data** to set the default behavior
+3. Save changes
+
+The default choice (copy or start fresh) will be pre-selected when creating new worktrees.
+
+### Use Cases
+
+- **Feature Development**: Copy session data when creating feature branches to maintain project context
+- **Experimentation**: Start fresh when testing unrelated changes
+- **Collaboration**: Share session state across team worktrees
+- **Context Preservation**: Maintain long conversations across multiple development branches
+
+
 ## Status Change Hooks
 
 CCManager can execute custom commands when Claude Code session status changes. This enables powerful automation workflows like desktop notifications, logging, or integration with other tools.

package/dist/components/App.js

@@ -150,11 +150,11 @@ const App = ({ devcontainerConfig }) => {
             }
         }, 50); // Small delay to ensure proper cleanup
     };
-    const handleCreateWorktree = async (path, branch, baseBranch, copyClaudeDirectory) => {
+    const handleCreateWorktree = async (path, branch, baseBranch, copySessionData, copyClaudeDirectory) => {
         setView('creating-worktree');
         setError(null);
         // Create the worktree
-        const result = worktreeService.createWorktree(path, branch, baseBranch, copyClaudeDirectory);
+        const result = worktreeService.createWorktree(path, branch, baseBranch, copySessionData, copyClaudeDirectory);
         if (result.success) {
             // Success - return to menu
             handleReturnToMenu();

package/dist/components/ConfigureWorktree.js

@@ -8,6 +8,7 @@ const ConfigureWorktree = ({ onComplete }) => {
     const worktreeConfig = configurationManager.getWorktreeConfig();
     const [autoDirectory, setAutoDirectory] = useState(worktreeConfig.autoDirectory);
     const [pattern, setPattern] = useState(worktreeConfig.autoDirectoryPattern || '../{branch}');
+    const [copySessionData, setCopySessionData] = useState(worktreeConfig.copySessionData ?? true);
     const [editMode, setEditMode] = useState('menu');
     const [tempPattern, setTempPattern] = useState(pattern);
     useInput((input, key) => {
@@ -25,6 +26,10 @@ const ConfigureWorktree = ({ onComplete }) => {
             label: `Pattern: ${pattern}`,
             value: 'pattern',
         },
+        {
+            label: `Copy Session Data: ${copySessionData ? '✅ Enabled' : '❌ Disabled'}`,
+            value: 'toggleCopy',
+        },
         {
             label: '💾 Save Changes',
             value: 'save',
@@ -43,11 +48,15 @@ const ConfigureWorktree = ({ onComplete }) => {
                 setTempPattern(pattern);
                 setEditMode('pattern');
                 break;
+            case 'toggleCopy':
+                setCopySessionData(!copySessionData);
+                break;
             case 'save':
                 // Save the configuration
                 configurationManager.setWorktreeConfig({
                     autoDirectory,
                     autoDirectoryPattern: pattern,
+                    copySessionData,
                 });
                 onComplete();
                 break;
@@ -83,7 +92,7 @@ const ConfigureWorktree = ({ onComplete }) => {
         React.createElement(Box, { marginBottom: 1 },
             React.createElement(Text, { bold: true, color: "green" }, "Configure Worktree Settings")),
         React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Text, { dimColor: true }, "Configure automatic worktree directory generation")),
+            React.createElement(Text, { dimColor: true }, "Configure worktree creation settings")),
         autoDirectory && (React.createElement(Box, { marginBottom: 1 },
             React.createElement(Text, null,
                 "Example: branch \"feature/my-feature\" \u2192 directory \"",

package/dist/components/NewWorktree.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 interface NewWorktreeProps {
-    onComplete: (path: string, branch: string, baseBranch: string, copyClaudeDirectory: boolean) => void;
+    onComplete: (path: string, branch: string, baseBranch: string, copySessionData: boolean, copyClaudeDirectory: boolean) => void;
     onCancel: () => void;
 }
 declare const NewWorktree: React.FC<NewWorktreeProps>;

package/dist/components/NewWorktree.js

@@ -14,6 +14,8 @@ const NewWorktree = ({ onComplete, onCancel }) => {
     const [path, setPath] = useState('');
     const [branch, setBranch] = useState('');
     const [baseBranch, setBaseBranch] = useState('');
+    const [copyClaudeDirectory, setCopyClaudeDirectory] = useState(true);
+    const [copySessionData, setCopySessionData] = useState(worktreeConfig.copySessionData ?? true);
     // Initialize worktree service and load branches (memoized to avoid re-initialization)
     const { branches, defaultBranch } = useMemo(() => {
         const service = new WorktreeService();
@@ -50,30 +52,22 @@ const NewWorktree = ({ onComplete, onCancel }) => {
     };
     const handleBaseBranchSelect = (item) => {
         setBaseBranch(item.value);
-        // Check if .claude directory exists in the base branch
-        const service = new WorktreeService();
-        if (service.hasClaudeDirectoryInBranch(item.value)) {
-            setStep('copy-settings');
-        }
-        else {
-            // Skip copy-settings step and complete with copySettings = false
-            if (isAutoDirectory) {
-                const autoPath = generateWorktreeDirectory(branch, worktreeConfig.autoDirectoryPattern);
-                onComplete(autoPath, branch, item.value, false);
-            }
-            else {
-                onComplete(path, branch, item.value, false);
-            }
-        }
+        setStep('copy-settings');
     };
     const handleCopySettingsSelect = (item) => {
+        setCopyClaudeDirectory(item.value);
+        setStep('copy-session');
+    };
+    const handleCopySessionSelect = (item) => {
+        const shouldCopy = item.value === 'yes';
+        setCopySessionData(shouldCopy);
         if (isAutoDirectory) {
             // Generate path from branch name
             const autoPath = generateWorktreeDirectory(branch, worktreeConfig.autoDirectoryPattern);
-            onComplete(autoPath, branch, baseBranch, item.value);
+            onComplete(autoPath, branch, baseBranch, shouldCopy, copyClaudeDirectory);
         }
         else {
-            onComplete(path, branch, baseBranch, item.value);
+            onComplete(path, branch, baseBranch, shouldCopy, copyClaudeDirectory);
         }
     };
     // Calculate generated path for preview (memoized to avoid expensive recalculations)
@@ -129,6 +123,15 @@ const NewWorktree = ({ onComplete, onCancel }) => {
                     },
                     { label: 'No - Start without .claude directory', value: false },
                 ], onSelect: handleCopySettingsSelect, initialIndex: 0 }))),
+        step === 'copy-session' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null, "Copy Claude Code session data to the new worktree?")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { dimColor: true }, "This will copy conversation history and context from the current worktree")),
+            React.createElement(SelectInput, { items: [
+                    { label: '✅ Yes, copy session data', value: 'yes' },
+                    { label: '❌ No, start fresh', value: 'no' },
+                ], onSelect: handleCopySessionSelect, initialIndex: copySessionData ? 0 : 1 }))),
         React.createElement(Box, { marginTop: 1 },
             React.createElement(Text, { dimColor: true },
                 "Press ",

package/dist/services/configurationManager.js

@@ -66,8 +66,12 @@ export class ConfigurationManager {
         if (!this.config.worktree) {
             this.config.worktree = {
                 autoDirectory: false,
+                copySessionData: true,
             };
         }
+        if (!Object.prototype.hasOwnProperty.call(this.config.worktree, 'copySessionData')) {
+            this.config.worktree.copySessionData = true;
+        }
         if (!this.config.command) {
             this.config.command = {
                 command: 'claude',

package/dist/services/sessionManager.d.ts

@@ -12,6 +12,13 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private createSessionInternal;
     createSessionWithPreset(worktreePath: string, presetId?: string): Promise<Session>;
     private setupDataHandler;
+    /**
+     * Sets up exit handler for the session process.
+     * When the process exits with code 1 and it's the primary command,
+     * it will attempt to spawn a fallback process.
+     * If fallbackArgs are configured, they will be used.
+     * If no fallbackArgs are configured, the command will be retried with no arguments.
+     */
     private setupExitHandler;
     private setupBackgroundHandler;
     private cleanupSession;

package/dist/services/sessionManager.js

@@ -99,31 +99,10 @@ export class SessionManager extends EventEmitter {
             args: preset.args,
             fallbackArgs: preset.fallbackArgs,
         };
-        // Try to spawn the process
-        let ptyProcess;
-        let isPrimaryCommand = true;
-        try {
-            ptyProcess = await this.spawn(command, args, worktreePath);
-        }
-        catch (error) {
-            // If primary command fails and we have fallback args, try them
-            if (preset.fallbackArgs) {
-                try {
-                    ptyProcess = await this.spawn(command, preset.fallbackArgs, worktreePath);
-                    isPrimaryCommand = false;
-                }
-                catch (_fallbackError) {
-                    // Both attempts failed, throw the original error
-                    throw error;
-                }
-            }
-            else {
-                // No fallback args, throw the error
-                throw error;
-            }
-        }
+        // Spawn the process - fallback will be handled by setupExitHandler
+        const ptyProcess = await this.spawn(command, args, worktreePath);
         return this.createSessionInternal(worktreePath, ptyProcess, commandConfig, {
-            isPrimaryCommand,
+            isPrimaryCommand: true,
             detectionStrategy: preset.detectionStrategy,
         });
     }
@@ -151,13 +130,40 @@ export class SessionManager extends EventEmitter {
             }
         });
     }
+    /**
+     * Sets up exit handler for the session process.
+     * When the process exits with code 1 and it's the primary command,
+     * it will attempt to spawn a fallback process.
+     * If fallbackArgs are configured, they will be used.
+     * If no fallbackArgs are configured, the command will be retried with no arguments.
+     */
     setupExitHandler(session) {
         session.process.onExit(async (e) => {
             // Check if we should attempt fallback
             if (e.exitCode === 1 && !e.signal && session.isPrimaryCommand) {
                 try {
-                    // Spawn fallback process
-                    const fallbackProcess = await this.spawn(session.commandConfig?.command || 'claude', session.commandConfig?.fallbackArgs || [], session.worktreePath);
+                    let fallbackProcess;
+                    // Use fallback args if available, otherwise use empty args
+                    const fallbackArgs = session.commandConfig?.fallbackArgs || [];
+                    // Check if we're in a devcontainer session
+                    if (session.devcontainerConfig) {
+                        // Parse the exec command to extract arguments
+                        const execParts = session.devcontainerConfig.execCommand.split(/\s+/);
+                        const devcontainerCmd = execParts[0] || 'devcontainer';
+                        const execArgs = execParts.slice(1);
+                        // Build fallback command for devcontainer
+                        const fallbackFullArgs = [
+                            ...execArgs,
+                            '--',
+                            session.commandConfig?.command || 'claude',
+                            ...fallbackArgs,
+                        ];
+                        fallbackProcess = await this.spawn(devcontainerCmd, fallbackFullArgs, session.worktreePath);
+                    }
+                    else {
+                        // Regular fallback without devcontainer
+                        fallbackProcess = await this.spawn(session.commandConfig?.command || 'claude', fallbackArgs, session.worktreePath);
+                    }
                     // Replace the process
                     session.process = fallbackProcess;
                     session.isPrimaryCommand = false;
@@ -304,7 +310,7 @@ export class SessionManager extends EventEmitter {
             preset.command,
             ...(preset.args || []),
         ];
-        // Spawn the process within devcontainer
+        // Spawn the process within devcontainer - fallback will be handled by setupExitHandler
         const ptyProcess = await this.spawn(devcontainerCmd, fullArgs, worktreePath);
         const commandConfig = {
             command: preset.command,

package/dist/services/sessionManager.test.js

@@ -155,7 +155,7 @@ describe('SessionManager', () => {
             expect(configurationManager.getDefaultPreset).toHaveBeenCalled();
             expect(spawn).toHaveBeenCalledWith('claude', [], expect.any(Object));
         });
-        it('should try fallback args with preset if main command fails', async () => {
+        it('should throw error when spawn fails with preset', async () => {
             // Setup mock preset with fallback
             vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
                 id: '1',
@@ -164,21 +164,15 @@ describe('SessionManager', () => {
                 args: ['--bad-flag'],
                 fallbackArgs: ['--good-flag'],
             });
-            // Mock spawn to fail first, succeed second
-            let callCount = 0;
+            // Mock spawn to fail
             vi.mocked(spawn).mockImplementation(() => {
-                callCount++;
-                if (callCount === 1) {
-                    throw new Error('Command failed');
-                }
-                return mockPty;
+                throw new Error('Command failed');
             });
-            // Create session
-            await sessionManager.createSessionWithPreset('/test/worktree');
-            // Verify both attempts were made
-            expect(spawn).toHaveBeenCalledTimes(2);
-            expect(spawn).toHaveBeenNthCalledWith(1, 'claude', ['--bad-flag'], expect.any(Object));
-            expect(spawn).toHaveBeenNthCalledWith(2, 'claude', ['--good-flag'], expect.any(Object));
+            // Expect createSessionWithPreset to throw
+            await expect(sessionManager.createSessionWithPreset('/test/worktree')).rejects.toThrow('Command failed');
+            // Verify only one spawn attempt was made
+            expect(spawn).toHaveBeenCalledTimes(1);
+            expect(spawn).toHaveBeenCalledWith('claude', ['--bad-flag'], expect.any(Object));
         });
         it('should return existing session if already created', async () => {
             // Setup mock preset
@@ -264,6 +258,39 @@ describe('SessionManager', () => {
             expect(spawn).toHaveBeenCalledTimes(1);
             expect(spawn).toHaveBeenCalledWith('claude', ['--resume'], expect.objectContaining({ cwd: '/test/worktree' }));
         });
+        it('should use empty args as fallback when no fallback args specified', async () => {
+            // Setup mock preset without fallback args
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+                args: ['--invalid-flag'],
+                // No fallbackArgs
+            });
+            // First spawn attempt - will exit with code 1
+            const firstMockPty = new MockPty();
+            // Second spawn attempt - succeeds
+            const secondMockPty = new MockPty();
+            vi.mocked(spawn)
+                .mockReturnValueOnce(firstMockPty)
+                .mockReturnValueOnce(secondMockPty);
+            // Create session
+            const session = await sessionManager.createSessionWithPreset('/test/worktree');
+            // Verify initial spawn
+            expect(spawn).toHaveBeenCalledTimes(1);
+            expect(spawn).toHaveBeenCalledWith('claude', ['--invalid-flag'], expect.objectContaining({ cwd: '/test/worktree' }));
+            // Simulate exit with code 1 on first attempt
+            firstMockPty.emit('exit', { exitCode: 1 });
+            // Wait for fallback to occur
+            await new Promise(resolve => setTimeout(resolve, 50));
+            // Verify fallback spawn was called with empty args
+            expect(spawn).toHaveBeenCalledTimes(2);
+            expect(spawn).toHaveBeenNthCalledWith(2, 'claude', [], // Empty args
+            expect.objectContaining({ cwd: '/test/worktree' }));
+            // Verify session process was replaced
+            expect(session.process).toBe(secondMockPty);
+            expect(session.isPrimaryCommand).toBe(false);
+        });
         it('should handle custom command configuration', async () => {
             // Setup mock preset with custom command
             vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
@@ -575,5 +602,96 @@ describe('SessionManager', () => {
                 'claude-3-opus',
             ], expect.any(Object));
         });
+        it('should use empty args as fallback in devcontainer when no fallback args specified', async () => {
+            const mockExec = vi.mocked(exec);
+            mockExec.mockImplementation((cmd, options, callback) => {
+                if (typeof options === 'function') {
+                    callback = options;
+                    options = undefined;
+                }
+                if (callback && typeof callback === 'function') {
+                    callback(null, 'Container started', '');
+                }
+                return {};
+            });
+            // Setup preset without fallback args
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+                args: ['--invalid-flag'],
+                // No fallbackArgs
+            });
+            // First spawn attempt - will exit with code 1
+            const firstMockPty = new MockPty();
+            // Second spawn attempt - succeeds
+            const secondMockPty = new MockPty();
+            vi.mocked(spawn)
+                .mockReturnValueOnce(firstMockPty)
+                .mockReturnValueOnce(secondMockPty);
+            const session = await sessionManager.createSessionWithDevcontainer('/test/worktree', {
+                upCommand: 'devcontainer up --workspace-folder .',
+                execCommand: 'devcontainer exec --workspace-folder .',
+            });
+            // Verify initial spawn
+            expect(spawn).toHaveBeenCalledTimes(1);
+            expect(spawn).toHaveBeenCalledWith('devcontainer', ['exec', '--workspace-folder', '.', '--', 'claude', '--invalid-flag'], expect.objectContaining({ cwd: '/test/worktree' }));
+            // Simulate exit with code 1 on first attempt
+            firstMockPty.emit('exit', { exitCode: 1 });
+            // Wait for fallback to occur
+            await new Promise(resolve => setTimeout(resolve, 50));
+            // Verify fallback spawn was called with empty args
+            expect(spawn).toHaveBeenCalledTimes(2);
+            expect(spawn).toHaveBeenNthCalledWith(2, 'devcontainer', ['exec', '--workspace-folder', '.', '--', 'claude'], // No args after claude
+            expect.objectContaining({ cwd: '/test/worktree' }));
+            // Verify session process was replaced
+            expect(session.process).toBe(secondMockPty);
+            expect(session.isPrimaryCommand).toBe(false);
+        });
+        it('should use fallback args in devcontainer when primary command exits with code 1', async () => {
+            const mockExec = vi.mocked(exec);
+            mockExec.mockImplementation((cmd, options, callback) => {
+                if (typeof options === 'function') {
+                    callback = options;
+                    options = undefined;
+                }
+                if (callback && typeof callback === 'function') {
+                    callback(null, 'Container started', '');
+                }
+                return {};
+            });
+            // Setup preset with fallback
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+                args: ['--bad-flag'],
+                fallbackArgs: ['--good-flag'],
+            });
+            // First spawn attempt - will exit with code 1
+            const firstMockPty = new MockPty();
+            // Second spawn attempt - succeeds
+            const secondMockPty = new MockPty();
+            vi.mocked(spawn)
+                .mockReturnValueOnce(firstMockPty)
+                .mockReturnValueOnce(secondMockPty);
+            const session = await sessionManager.createSessionWithDevcontainer('/test/worktree', {
+                upCommand: 'devcontainer up --workspace-folder .',
+                execCommand: 'devcontainer exec --workspace-folder .',
+            });
+            // Verify initial spawn
+            expect(spawn).toHaveBeenCalledTimes(1);
+            expect(spawn).toHaveBeenCalledWith('devcontainer', ['exec', '--workspace-folder', '.', '--', 'claude', '--bad-flag'], expect.objectContaining({ cwd: '/test/worktree' }));
+            // Simulate exit with code 1 on first attempt
+            firstMockPty.emit('exit', { exitCode: 1 });
+            // Wait for fallback to occur
+            await new Promise(resolve => setTimeout(resolve, 50));
+            // Verify fallback spawn was called
+            expect(spawn).toHaveBeenCalledTimes(2);
+            expect(spawn).toHaveBeenNthCalledWith(2, 'devcontainer', ['exec', '--workspace-folder', '.', '--', 'claude', '--good-flag'], expect.objectContaining({ cwd: '/test/worktree' }));
+            // Verify session process was replaced
+            expect(session.process).toBe(secondMockPty);
+            expect(session.isPrimaryCommand).toBe(false);
+        });
     });
 });

package/dist/services/worktreeService.d.ts

@@ -9,7 +9,7 @@ export declare class WorktreeService {
     isGitRepository(): boolean;
     getDefaultBranch(): string;
     getAllBranches(): string[];
-    createWorktree(worktreePath: string, branch: string, baseBranch: string, copyClaudeDirectory?: boolean): {
+    createWorktree(worktreePath: string, branch: string, baseBranch: string, copySessionData?: boolean, copyClaudeDirectory?: boolean): {
         success: boolean;
         error?: string;
     };
@@ -27,6 +27,7 @@ export declare class WorktreeService {
         success: boolean;
         error?: string;
     };
+    private copyClaudeSessionData;
     hasClaudeDirectoryInBranch(branchName: string): boolean;
     private copyClaudeDirectoryFromBaseBranch;
 }

package/dist/services/worktreeService.js

@@ -2,6 +2,7 @@ import { execSync } from 'child_process';
 import { existsSync, statSync, cpSync } from 'fs';
 import path from 'path';
 import { setWorktreeParentBranch } from '../utils/worktreeConfig.js';
+import { getClaudeProjectsDir, pathToClaudeProjectName, } from '../utils/claudeDir.js';
 const CLAUDE_DIR = '.claude';
 export class WorktreeService {
     constructor(rootPath) {
@@ -172,7 +173,7 @@ export class WorktreeService {
             return [];
         }
     }
-    createWorktree(worktreePath, branch, baseBranch, copyClaudeDirectory = false) {
+    createWorktree(worktreePath, branch, baseBranch, copySessionData = false, copyClaudeDirectory = false) {
         try {
             // Resolve the worktree path relative to the git repository root
             const resolvedPath = path.isAbsolute(worktreePath)
@@ -203,6 +204,10 @@ export class WorktreeService {
                 cwd: this.gitRootPath, // Execute from git root to ensure proper resolution
                 encoding: 'utf8',
             });
+            // Copy session data if requested
+            if (copySessionData) {
+                this.copyClaudeSessionData(this.rootPath, resolvedPath);
+            }
             // Store the parent branch in worktree config
             try {
                 setWorktreeParentBranch(resolvedPath, baseBranch);
@@ -348,6 +353,32 @@ export class WorktreeService {
             };
         }
     }
+    copyClaudeSessionData(sourceWorktreePath, targetWorktreePath) {
+        try {
+            const projectsDir = getClaudeProjectsDir();
+            if (!existsSync(projectsDir)) {
+                throw new Error(`Claude projects directory does not exist: ${projectsDir}`);
+            }
+            // Convert paths to Claude's naming convention
+            const sourceProjectName = pathToClaudeProjectName(sourceWorktreePath);
+            const targetProjectName = pathToClaudeProjectName(targetWorktreePath);
+            const sourceProjectDir = path.join(projectsDir, sourceProjectName);
+            const targetProjectDir = path.join(projectsDir, targetProjectName);
+            // Only copy if source project exists
+            if (existsSync(sourceProjectDir)) {
+                cpSync(sourceProjectDir, targetProjectDir, {
+                    recursive: true,
+                    force: true,
+                    errorOnExist: false,
+                    preserveTimestamps: true,
+                });
+            }
+        }
+        catch (error) {
+            console.error(`Failed to copy Claude session data: ${error}`);
+            throw new Error(`Failed to copy Claude session data: ${error}`);
+        }
+    }
     hasClaudeDirectoryInBranch(branchName) {
         // Find the worktree directory for the branch
         const worktrees = this.getWorktrees();

package/dist/types/index.d.ts

@@ -57,6 +57,7 @@ export interface StatusHookConfig {
 export interface WorktreeConfig {
     autoDirectory: boolean;
     autoDirectoryPattern?: string;
+    copySessionData?: boolean;
 }
 export interface CommandConfig {
     command: string;

package/dist/utils/claudeDir.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @fileoverview Utilities for Claude Code directory and project path handling.
+ * Provides functions to get Claude configuration directories respecting the
+ * CLAUDE_CONFIG_DIR environment variable and convert worktree paths to Claude's
+ * project naming convention.
+ */
+/**
+ * Get the Claude directory path, respecting CLAUDE_CONFIG_DIR environment variable
+ * @returns The Claude directory path
+ */
+export declare function getClaudeDir(): string;
+/**
+ * Get the Claude projects directory path
+ * @returns The Claude projects directory path
+ */
+export declare function getClaudeProjectsDir(): string;
+/**
+ * Convert a worktree path to Claude's project naming convention
+ * @param worktreePath The path to the worktree
+ * @returns The project name used by Claude
+ */
+export declare function pathToClaudeProjectName(worktreePath: string): string;

package/dist/utils/claudeDir.js

@@ -0,0 +1,39 @@
+/**
+ * @fileoverview Utilities for Claude Code directory and project path handling.
+ * Provides functions to get Claude configuration directories respecting the
+ * CLAUDE_CONFIG_DIR environment variable and convert worktree paths to Claude's
+ * project naming convention.
+ */
+import path from 'path';
+import os from 'os';
+/**
+ * Get the Claude directory path, respecting CLAUDE_CONFIG_DIR environment variable
+ * @returns The Claude directory path
+ */
+export function getClaudeDir() {
+    const envConfigDir = process.env['CLAUDE_CONFIG_DIR'];
+    if (envConfigDir) {
+        return envConfigDir.trim();
+    }
+    // Default to ~/.claude for backward compatibility and when not set
+    return path.join(os.homedir(), '.claude');
+}
+/**
+ * Get the Claude projects directory path
+ * @returns The Claude projects directory path
+ */
+export function getClaudeProjectsDir() {
+    return path.join(getClaudeDir(), 'projects');
+}
+/**
+ * Convert a worktree path to Claude's project naming convention
+ * @param worktreePath The path to the worktree
+ * @returns The project name used by Claude
+ */
+export function pathToClaudeProjectName(worktreePath) {
+    // Convert absolute path to Claude's project naming convention
+    // Claude replaces all path separators and dots with dashes
+    const resolved = path.resolve(worktreePath);
+    // Handle both forward slashes (Linux/macOS) and backslashes (Windows)
+    return resolved.replace(/[/\\.]/g, '-');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "1.3.0",
+	"version": "1.4.0",
 	"description": "TUI application for managing multiple Claude Code sessions across Git worktrees",
 	"license": "MIT",
 	"author": "Kodai Kabasawa",