ccmanager 1.3.1 → 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/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.1",
+	"version": "1.4.0",
 	"description": "TUI application for managing multiple Claude Code sessions across Git worktrees",
 	"license": "MIT",
 	"author": "Kodai Kabasawa",