ccmanager 1.1.1 → 1.3.0

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/dist/types/index.d.ts

@@ -26,10 +26,10 @@ export interface Session {
     isPrimaryCommand?: boolean;
     commandConfig?: CommandConfig;
     detectionStrategy?: StateDetectionStrategy;
+    devcontainerConfig?: DevcontainerConfig;
 }
 export interface SessionManager {
     sessions: Map<string, Session>;
-    createSession(worktreePath: string): Promise<Session>;
     getSession(worktreePath: string): Session | undefined;
     destroySession(worktreePath: string): void;
     getAllSessions(): Session[];
@@ -76,6 +76,10 @@ export interface CommandPresetsConfig {
     defaultPresetId: string;
     selectPresetOnStart?: boolean;
 }
+export interface DevcontainerConfig {
+    upCommand: string;
+    execCommand: string;
+}
 export interface ConfigurationData {
     shortcuts?: ShortcutConfig;
     statusHooks?: StatusHookConfig;

package/package.json

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