ccmanager 1.1.1 → 1.2.0

package/dist/components/App.js

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

package/dist/components/NewWorktree.d.ts

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

package/dist/components/NewWorktree.js

@@ -13,6 +13,7 @@ const NewWorktree = ({ onComplete, onCancel }) => {
     const [step, setStep] = useState(isAutoDirectory ? 'branch' : 'path');
     const [path, setPath] = useState('');
     const [branch, setBranch] = useState('');
+    const [baseBranch, setBaseBranch] = useState('');
     // Initialize worktree service and load branches (memoized to avoid re-initialization)
     const { branches, defaultBranch } = useMemo(() => {
         const service = new WorktreeService();
@@ -48,13 +49,31 @@ 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);
+            }
+        }
+    };
+    const handleCopySettingsSelect = (item) => {
         if (isAutoDirectory) {
             // Generate path from branch name
             const autoPath = generateWorktreeDirectory(branch, worktreeConfig.autoDirectoryPattern);
-            onComplete(autoPath, branch, item.value);
+            onComplete(autoPath, branch, baseBranch, item.value);
         }
         else {
-            onComplete(path, branch, item.value);
+            onComplete(path, branch, baseBranch, item.value);
         }
     };
     // Calculate generated path for preview (memoized to avoid expensive recalculations)
@@ -97,6 +116,19 @@ const NewWorktree = ({ onComplete, onCancel }) => {
                     React.createElement(Text, { color: "cyan" }, branch),
                     ":")),
             React.createElement(SelectInput, { items: branchItems, onSelect: handleBaseBranchSelect, initialIndex: 0, limit: 10 }))),
+        step === 'copy-settings' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null,
+                    "Copy .claude directory from base branch (",
+                    React.createElement(Text, { color: "cyan" }, baseBranch),
+                    ")?")),
+            React.createElement(SelectInput, { items: [
+                    {
+                        label: 'Yes - Copy .claude directory from base branch',
+                        value: true,
+                    },
+                    { label: 'No - Start without .claude directory', value: false },
+                ], onSelect: handleCopySettingsSelect, initialIndex: 0 }))),
         React.createElement(Box, { marginTop: 1 },
             React.createElement(Text, { dimColor: true },
                 "Press ",

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): {
+    createWorktree(worktreePath: string, branch: string, baseBranch: string, copyClaudeDirectory?: boolean): {
         success: boolean;
         error?: string;
     };
@@ -27,4 +27,6 @@ export declare class WorktreeService {
         success: boolean;
         error?: string;
     };
+    hasClaudeDirectoryInBranch(branchName: string): boolean;
+    private copyClaudeDirectoryFromBaseBranch;
 }

package/dist/services/worktreeService.js

@@ -1,7 +1,8 @@
 import { execSync } from 'child_process';
-import { existsSync } from 'fs';
+import { existsSync, statSync, cpSync } from 'fs';
 import path from 'path';
 import { setWorktreeParentBranch } from '../utils/worktreeConfig.js';
+const CLAUDE_DIR = '.claude';
 export class WorktreeService {
     constructor(rootPath) {
         Object.defineProperty(this, "rootPath", {
@@ -171,7 +172,7 @@ export class WorktreeService {
             return [];
         }
     }
-    createWorktree(worktreePath, branch, baseBranch) {
+    createWorktree(worktreePath, branch, baseBranch, copyClaudeDirectory = false) {
         try {
             // Resolve the worktree path relative to the git repository root
             const resolvedPath = path.isAbsolute(worktreePath)
@@ -209,6 +210,15 @@ export class WorktreeService {
             catch (error) {
                 console.error('Warning: Failed to set parent branch in worktree config:', error);
             }
+            // Copy .claude directory if requested
+            if (copyClaudeDirectory) {
+                try {
+                    this.copyClaudeDirectoryFromBaseBranch(resolvedPath, baseBranch);
+                }
+                catch (error) {
+                    console.error('Warning: Failed to copy .claude directory:', error);
+                }
+            }
             return { success: true };
         }
         catch (error) {
@@ -338,4 +348,53 @@ export class WorktreeService {
             };
         }
     }
+    hasClaudeDirectoryInBranch(branchName) {
+        // Find the worktree directory for the branch
+        const worktrees = this.getWorktrees();
+        let targetWorktree = worktrees.find(wt => wt.branch && wt.branch.replace('refs/heads/', '') === branchName);
+        // If branch worktree not found, try the default branch
+        if (!targetWorktree) {
+            const defaultBranch = this.getDefaultBranch();
+            if (branchName === defaultBranch) {
+                targetWorktree = worktrees.find(wt => wt.branch && wt.branch.replace('refs/heads/', '') === defaultBranch);
+            }
+        }
+        // If still not found and it's the default branch, try the main worktree
+        if (!targetWorktree && branchName === this.getDefaultBranch()) {
+            targetWorktree = worktrees.find(wt => wt.isMainWorktree);
+        }
+        if (!targetWorktree) {
+            return false;
+        }
+        // Check if .claude directory exists in the worktree
+        const claudePath = path.join(targetWorktree.path, CLAUDE_DIR);
+        return existsSync(claudePath) && statSync(claudePath).isDirectory();
+    }
+    copyClaudeDirectoryFromBaseBranch(worktreePath, baseBranch) {
+        // Find the worktree directory for the base branch
+        const worktrees = this.getWorktrees();
+        let baseWorktree = worktrees.find(wt => wt.branch && wt.branch.replace('refs/heads/', '') === baseBranch);
+        // If base branch worktree not found, try the default branch
+        if (!baseWorktree) {
+            const defaultBranch = this.getDefaultBranch();
+            baseWorktree = worktrees.find(wt => wt.branch && wt.branch.replace('refs/heads/', '') === defaultBranch);
+        }
+        // If still not found, try the main worktree
+        if (!baseWorktree) {
+            baseWorktree = worktrees.find(wt => wt.isMainWorktree);
+        }
+        if (!baseWorktree) {
+            throw new Error('Could not find base worktree to copy settings from');
+        }
+        // Check if .claude directory exists in base worktree
+        const sourceClaudeDir = path.join(baseWorktree.path, CLAUDE_DIR);
+        if (!existsSync(sourceClaudeDir) ||
+            !statSync(sourceClaudeDir).isDirectory()) {
+            // No .claude directory to copy, this is fine
+            return;
+        }
+        // Copy .claude directory to new worktree
+        const targetClaudeDir = path.join(worktreePath, CLAUDE_DIR);
+        cpSync(sourceClaudeDir, targetClaudeDir, { recursive: true });
+    }
 }

package/dist/services/worktreeService.test.js

@@ -1,8 +1,11 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { WorktreeService } from './worktreeService.js';
 import { execSync } from 'child_process';
+import { existsSync, statSync } from 'fs';
 // Mock child_process module
 vi.mock('child_process');
+// Mock fs module
+vi.mock('fs');
 // Mock worktreeConfigManager
 vi.mock('./worktreeConfigManager.js', () => ({
     worktreeConfigManager: {
@@ -13,6 +16,8 @@ vi.mock('./worktreeConfigManager.js', () => ({
 }));
 // Get the mocked function with proper typing
 const mockedExecSync = vi.mocked(execSync);
+const mockedExistsSync = vi.mocked(existsSync);
+const mockedStatSync = vi.mocked(statSync);
 describe('WorktreeService', () => {
     let service;
     beforeEach(() => {
@@ -152,4 +157,164 @@ origin/feature/test
             expect(execSync).toHaveBeenCalledWith('git worktree add -b "new-feature" "/path/to/worktree" "main"', expect.any(Object));
         });
     });
+    describe('hasClaudeDirectoryInBranch', () => {
+        it('should return true when .claude directory exists in branch worktree', () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd === 'git worktree list --porcelain') {
+                        return `worktree /fake/path
+HEAD abcd1234
+branch refs/heads/main
+
+worktree /fake/path/feature-branch
+HEAD efgh5678
+branch refs/heads/feature-branch
+`;
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            mockedExistsSync.mockImplementation(path => {
+                return path === '/fake/path/feature-branch/.claude';
+            });
+            mockedStatSync.mockImplementation(() => ({
+                isDirectory: () => true,
+            }));
+            const result = service.hasClaudeDirectoryInBranch('feature-branch');
+            expect(result).toBe(true);
+            expect(existsSync).toHaveBeenCalledWith('/fake/path/feature-branch/.claude');
+            expect(statSync).toHaveBeenCalledWith('/fake/path/feature-branch/.claude');
+        });
+        it('should return false when .claude directory does not exist', () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd === 'git worktree list --porcelain') {
+                        return `worktree /fake/path
+HEAD abcd1234
+branch refs/heads/main
+
+worktree /fake/path/feature-branch
+HEAD efgh5678
+branch refs/heads/feature-branch
+`;
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            mockedExistsSync.mockReturnValue(false);
+            const result = service.hasClaudeDirectoryInBranch('feature-branch');
+            expect(result).toBe(false);
+            expect(existsSync).toHaveBeenCalledWith('/fake/path/feature-branch/.claude');
+        });
+        it('should return false when .claude exists but is not a directory', () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd === 'git worktree list --porcelain') {
+                        return `worktree /fake/path
+HEAD abcd1234
+branch refs/heads/main
+
+worktree /fake/path/feature-branch
+HEAD efgh5678
+branch refs/heads/feature-branch
+`;
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            mockedExistsSync.mockReturnValue(true);
+            mockedStatSync.mockImplementation(() => ({
+                isDirectory: () => false,
+            }));
+            const result = service.hasClaudeDirectoryInBranch('feature-branch');
+            expect(result).toBe(false);
+        });
+        it('should fallback to default branch when branch worktree not found', () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd === 'git worktree list --porcelain') {
+                        return `worktree /fake/path
+HEAD abcd1234
+branch refs/heads/main
+`;
+                    }
+                    if (cmd.includes('symbolic-ref')) {
+                        return 'main\n';
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            mockedExistsSync.mockReturnValue(true);
+            mockedStatSync.mockImplementation(() => ({
+                isDirectory: () => true,
+            }));
+            // When asking for main branch that doesn't have a separate worktree
+            const result = service.hasClaudeDirectoryInBranch('main');
+            expect(result).toBe(true);
+            expect(existsSync).toHaveBeenCalledWith('/fake/path/.claude');
+        });
+        it('should return false when branch not found in any worktree', () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd === 'git worktree list --porcelain') {
+                        return `worktree /fake/path
+HEAD abcd1234
+branch refs/heads/main
+`;
+                    }
+                    if (cmd.includes('symbolic-ref')) {
+                        return 'main\n';
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const result = service.hasClaudeDirectoryInBranch('non-existent-branch');
+            expect(result).toBe(false);
+        });
+        it('should check main worktree when branch is default branch', () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd === 'git worktree list --porcelain') {
+                        return `worktree /fake/path
+HEAD abcd1234
+branch refs/heads/main
+
+worktree /fake/path/other-branch
+HEAD efgh5678
+branch refs/heads/other-branch
+`;
+                    }
+                    if (cmd.includes('symbolic-ref')) {
+                        return 'main\n';
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            mockedExistsSync.mockReturnValue(true);
+            mockedStatSync.mockImplementation(() => ({
+                isDirectory: () => true,
+            }));
+            const result = service.hasClaudeDirectoryInBranch('main');
+            expect(result).toBe(true);
+            expect(existsSync).toHaveBeenCalledWith('/fake/path/.claude');
+        });
+    });
 });

package/package.json

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