ccmanager 0.1.5 → 0.1.7

package/dist/components/App.js

@@ -102,11 +102,11 @@ const App = () => {
             }
         }, 50); // Small delay to ensure proper cleanup
     };
-    const handleCreateWorktree = async (path, branch) => {
+    const handleCreateWorktree = async (path, branch, baseBranch) => {
         setView('creating-worktree');
         setError(null);
         // Create the worktree
-        const result = worktreeService.createWorktree(path, branch);
+        const result = worktreeService.createWorktree(path, branch, baseBranch);
         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) => void;
+    onComplete: (path: string, branch: string, baseBranch: string) => void;
     onCancel: () => void;
 }
 declare const NewWorktree: React.FC<NewWorktreeProps>;

package/dist/components/NewWorktree.js

@@ -1,9 +1,11 @@
-import React, { useState, useEffect } from 'react';
+import React, { useState, useMemo } from 'react';
 import { Box, Text, useInput } from 'ink';
 import TextInput from 'ink-text-input';
+import SelectInput from 'ink-select-input';
 import { shortcutManager } from '../services/shortcutManager.js';
 import { configurationManager } from '../services/configurationManager.js';
 import { generateWorktreeDirectory } from '../utils/worktreeUtils.js';
+import { WorktreeService } from '../services/worktreeService.js';
 const NewWorktree = ({ onComplete, onCancel }) => {
     const worktreeConfig = configurationManager.getWorktreeConfig();
     const isAutoDirectory = worktreeConfig.autoDirectory;
@@ -11,7 +13,23 @@ const NewWorktree = ({ onComplete, onCancel }) => {
     const [step, setStep] = useState(isAutoDirectory ? 'branch' : 'path');
     const [path, setPath] = useState('');
     const [branch, setBranch] = useState('');
-    const [generatedPath, setGeneratedPath] = useState('');
+    // Initialize worktree service and load branches (memoized to avoid re-initialization)
+    const { branches, defaultBranch } = useMemo(() => {
+        const service = new WorktreeService();
+        const allBranches = service.getAllBranches();
+        const defaultBr = service.getDefaultBranch();
+        return {
+            branches: allBranches,
+            defaultBranch: defaultBr,
+        };
+    }, []); // Empty deps array - only initialize once
+    // Create branch items with default branch first (memoized)
+    const branchItems = useMemo(() => [
+        { label: `${defaultBranch} (default)`, value: defaultBranch },
+        ...branches
+            .filter(br => br !== defaultBranch)
+            .map(br => ({ label: br, value: br })),
+    ], [branches, defaultBranch]);
     useInput((input, key) => {
         if (shortcutManager.matchesShortcut('cancel', input, key)) {
             onCancel();
@@ -26,23 +44,25 @@ const NewWorktree = ({ onComplete, onCancel }) => {
     const handleBranchSubmit = (value) => {
         if (value.trim()) {
             setBranch(value.trim());
-            if (isAutoDirectory) {
-                // Generate path from branch name
-                const autoPath = generateWorktreeDirectory(value.trim(), worktreeConfig.autoDirectoryPattern);
-                onComplete(autoPath, value.trim());
-            }
-            else {
-                onComplete(path, value.trim());
-            }
+            setStep('base-branch');
         }
     };
-    // Update generated path preview when branch changes in auto mode
-    useEffect(() => {
-        if (isAutoDirectory && branch) {
+    const handleBaseBranchSelect = (item) => {
+        if (isAutoDirectory) {
+            // Generate path from branch name
             const autoPath = generateWorktreeDirectory(branch, worktreeConfig.autoDirectoryPattern);
-            setGeneratedPath(autoPath);
+            onComplete(autoPath, branch, item.value);
         }
-    }, [branch, isAutoDirectory, worktreeConfig.autoDirectoryPattern]);
+        else {
+            onComplete(path, branch, item.value);
+        }
+    };
+    // Calculate generated path for preview (memoized to avoid expensive recalculations)
+    const generatedPath = useMemo(() => {
+        return isAutoDirectory && branch
+            ? generateWorktreeDirectory(branch, worktreeConfig.autoDirectoryPattern)
+            : '';
+    }, [isAutoDirectory, branch, worktreeConfig.autoDirectoryPattern]);
     return (React.createElement(Box, { flexDirection: "column" },
         React.createElement(Box, { marginBottom: 1 },
             React.createElement(Text, { bold: true, color: "green" }, "Create New Worktree")),
@@ -70,6 +90,13 @@ const NewWorktree = ({ onComplete, onCancel }) => {
                     "Worktree will be created at:",
                     ' ',
                     React.createElement(Text, { color: "green" }, generatedPath)))))),
+        step === 'base-branch' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null,
+                    "Select base branch for ",
+                    React.createElement(Text, { color: "cyan" }, branch),
+                    ":")),
+            React.createElement(SelectInput, { items: branchItems, onSelect: handleBaseBranchSelect, initialIndex: 0 }))),
         React.createElement(Box, { marginTop: 1 },
             React.createElement(Text, { dimColor: true },
                 "Press ",

package/dist/services/worktreeService.d.ts

@@ -1,11 +1,15 @@
 import { Worktree } from '../types/index.js';
 export declare class WorktreeService {
     private rootPath;
+    private gitRootPath;
     constructor(rootPath?: string);
+    private getGitRepositoryRoot;
     getWorktrees(): Worktree[];
     private getCurrentBranch;
     isGitRepository(): boolean;
-    createWorktree(worktreePath: string, branch: string): {
+    getDefaultBranch(): string;
+    getAllBranches(): string[];
+    createWorktree(worktreePath: string, branch: string, baseBranch: string): {
         success: boolean;
         error?: string;
     };

package/dist/services/worktreeService.js

@@ -9,7 +9,30 @@ export class WorktreeService {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "gitRootPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.rootPath = rootPath || process.cwd();
+        // Get the actual git repository root for worktree operations
+        this.gitRootPath = this.getGitRepositoryRoot();
+    }
+    getGitRepositoryRoot() {
+        try {
+            // Get the common git directory
+            const gitCommonDir = execSync('git rev-parse --git-common-dir', {
+                cwd: this.rootPath,
+                encoding: 'utf8',
+            }).trim();
+            // The parent of .git is the actual repository root
+            return path.dirname(gitCommonDir);
+        }
+        catch {
+            // Fallback to current directory if command fails
+            return this.rootPath;
+        }
     }
     getWorktrees() {
         try {
@@ -79,8 +102,71 @@ export class WorktreeService {
     isGitRepository() {
         return existsSync(path.join(this.rootPath, '.git'));
     }
-    createWorktree(worktreePath, branch) {
+    getDefaultBranch() {
+        try {
+            // Try to get the default branch from origin
+            const defaultBranch = execSync("git symbolic-ref refs/remotes/origin/HEAD | sed 's@^refs/remotes/origin/@@'", {
+                cwd: this.rootPath,
+                encoding: 'utf8',
+                shell: '/bin/bash',
+            }).trim();
+            return defaultBranch || 'main';
+        }
+        catch {
+            // Fallback to common default branch names
+            try {
+                execSync('git rev-parse --verify main', {
+                    cwd: this.rootPath,
+                    encoding: 'utf8',
+                });
+                return 'main';
+            }
+            catch {
+                try {
+                    execSync('git rev-parse --verify master', {
+                        cwd: this.rootPath,
+                        encoding: 'utf8',
+                    });
+                    return 'master';
+                }
+                catch {
+                    return 'main';
+                }
+            }
+        }
+    }
+    getAllBranches() {
         try {
+            const output = execSync("git branch -a --format='%(refname:short)' | grep -v HEAD | sort -u", {
+                cwd: this.rootPath,
+                encoding: 'utf8',
+                shell: '/bin/bash',
+            });
+            const branches = output
+                .trim()
+                .split('\n')
+                .filter(branch => branch && !branch.startsWith('origin/'))
+                .map(branch => branch.trim());
+            // Also include remote branches without origin/ prefix
+            const remoteBranches = output
+                .trim()
+                .split('\n')
+                .filter(branch => branch.startsWith('origin/'))
+                .map(branch => branch.replace('origin/', ''));
+            // Merge and deduplicate
+            const allBranches = [...new Set([...branches, ...remoteBranches])];
+            return allBranches.filter(branch => branch);
+        }
+        catch {
+            return [];
+        }
+    }
+    createWorktree(worktreePath, branch, baseBranch) {
+        try {
+            // Resolve the worktree path relative to the git repository root
+            const resolvedPath = path.isAbsolute(worktreePath)
+                ? worktreePath
+                : path.join(this.gitRootPath, worktreePath);
             // Check if branch exists
             let branchExists = false;
             try {
@@ -94,11 +180,16 @@ export class WorktreeService {
                 // Branch doesn't exist
             }
             // Create the worktree
-            const command = branchExists
-                ? `git worktree add "${worktreePath}" "${branch}"`
-                : `git worktree add -b "${branch}" "${worktreePath}"`;
+            let command;
+            if (branchExists) {
+                command = `git worktree add "${resolvedPath}" "${branch}"`;
+            }
+            else {
+                // Create new branch from specified base branch
+                command = `git worktree add -b "${branch}" "${resolvedPath}" "${baseBranch}"`;
+            }
             execSync(command, {
-                cwd: this.rootPath,
+                cwd: this.gitRootPath, // Execute from git root to ensure proper resolution
                 encoding: 'utf8',
             });
             return { success: true };

package/dist/services/worktreeService.test.d.ts

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

package/dist/services/worktreeService.test.js

@@ -0,0 +1,147 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { WorktreeService } from './worktreeService.js';
+import { execSync } from 'child_process';
+// Mock child_process module
+vi.mock('child_process');
+// Get the mocked function with proper typing
+const mockedExecSync = vi.mocked(execSync);
+describe('WorktreeService', () => {
+    let service;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Mock git rev-parse --git-common-dir to return a predictable path
+        mockedExecSync.mockImplementation((cmd, _options) => {
+            if (typeof cmd === 'string' && cmd === 'git rev-parse --git-common-dir') {
+                return '/fake/path/.git\n';
+            }
+            throw new Error('Command not mocked: ' + cmd);
+        });
+        service = new WorktreeService('/fake/path');
+    });
+    describe('getDefaultBranch', () => {
+        it('should return default branch from origin', () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('symbolic-ref')) {
+                        return 'main\n';
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const result = service.getDefaultBranch();
+            expect(result).toBe('main');
+            expect(execSync).toHaveBeenCalledWith("git symbolic-ref refs/remotes/origin/HEAD | sed 's@^refs/remotes/origin/@@'", expect.objectContaining({
+                cwd: '/fake/path',
+                encoding: 'utf8',
+                shell: '/bin/bash',
+            }));
+        });
+        it('should fallback to main if origin HEAD fails', () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('symbolic-ref')) {
+                        throw new Error('No origin');
+                    }
+                    if (cmd.includes('rev-parse --verify main')) {
+                        return 'hash';
+                    }
+                }
+                throw new Error('Not found');
+            });
+            const result = service.getDefaultBranch();
+            expect(result).toBe('main');
+        });
+    });
+    describe('getAllBranches', () => {
+        it('should return all branches without duplicates', () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('branch -a')) {
+                        return `main
+feature/test
+origin/main
+origin/feature/remote
+origin/feature/test
+`;
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const result = service.getAllBranches();
+            expect(result).toEqual(['main', 'feature/test', 'feature/remote']);
+        });
+        it('should return empty array on error', () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string' &&
+                    cmd === 'git rev-parse --git-common-dir') {
+                    return '/fake/path/.git\n';
+                }
+                throw new Error('Git error');
+            });
+            const result = service.getAllBranches();
+            expect(result).toEqual([]);
+        });
+    });
+    describe('createWorktree', () => {
+        it('should create worktree with base branch when branch 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.includes('rev-parse --verify')) {
+                        throw new Error('Branch not found');
+                    }
+                    return '';
+                }
+                throw new Error('Unexpected command');
+            });
+            const result = service.createWorktree('/path/to/worktree', 'new-feature', 'develop');
+            expect(result).toEqual({ success: true });
+            expect(execSync).toHaveBeenCalledWith('git worktree add -b "new-feature" "/path/to/worktree" "develop"', expect.any(Object));
+        });
+        it('should create worktree without base branch when branch exists', () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('rev-parse --verify')) {
+                        return 'hash';
+                    }
+                    return '';
+                }
+                throw new Error('Unexpected command');
+            });
+            const result = service.createWorktree('/path/to/worktree', 'existing-feature', 'main');
+            expect(result).toEqual({ success: true });
+            expect(execSync).toHaveBeenCalledWith('git worktree add "/path/to/worktree" "existing-feature"', expect.any(Object));
+        });
+        it('should create worktree from specified base branch when branch 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.includes('rev-parse --verify')) {
+                        throw new Error('Branch not found');
+                    }
+                    return '';
+                }
+                throw new Error('Unexpected command');
+            });
+            const result = service.createWorktree('/path/to/worktree', 'new-feature', 'main');
+            expect(result).toEqual({ success: true });
+            expect(execSync).toHaveBeenCalledWith('git worktree add -b "new-feature" "/path/to/worktree" "main"', expect.any(Object));
+        });
+    });
+});

package/package.json

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