ccmanager 0.1.4 → 0.1.6

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/Configuration.js

@@ -3,6 +3,7 @@ import { Box, Text } from 'ink';
 import SelectInput from 'ink-select-input';
 import ConfigureShortcuts from './ConfigureShortcuts.js';
 import ConfigureHooks from './ConfigureHooks.js';
+import ConfigureWorktree from './ConfigureWorktree.js';
 const Configuration = ({ onComplete }) => {
     const [view, setView] = useState('menu');
     const menuItems = [
@@ -14,6 +15,10 @@ const Configuration = ({ onComplete }) => {
             label: '🔧  Configure Status Hooks',
             value: 'hooks',
         },
+        {
+            label: '📁  Configure Worktree Settings',
+            value: 'worktree',
+        },
         {
             label: '← Back to Main Menu',
             value: 'back',
@@ -29,6 +34,9 @@ const Configuration = ({ onComplete }) => {
         else if (item.value === 'hooks') {
             setView('hooks');
         }
+        else if (item.value === 'worktree') {
+            setView('worktree');
+        }
     };
     const handleSubMenuComplete = () => {
         setView('menu');
@@ -39,6 +47,9 @@ const Configuration = ({ onComplete }) => {
     if (view === 'hooks') {
         return React.createElement(ConfigureHooks, { onComplete: handleSubMenuComplete });
     }
+    if (view === 'worktree') {
+        return React.createElement(ConfigureWorktree, { onComplete: handleSubMenuComplete });
+    }
     return (React.createElement(Box, { flexDirection: "column" },
         React.createElement(Box, { marginBottom: 1 },
             React.createElement(Text, { bold: true, color: "green" }, "Configuration")),

package/dist/components/ConfigureWorktree.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface ConfigureWorktreeProps {
+    onComplete: () => void;
+}
+declare const ConfigureWorktree: React.FC<ConfigureWorktreeProps>;
+export default ConfigureWorktree;

package/dist/components/ConfigureWorktree.js

@@ -0,0 +1,99 @@
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import SelectInput from 'ink-select-input';
+import TextInput from 'ink-text-input';
+import { configurationManager } from '../services/configurationManager.js';
+import { shortcutManager } from '../services/shortcutManager.js';
+const ConfigureWorktree = ({ onComplete }) => {
+    const worktreeConfig = configurationManager.getWorktreeConfig();
+    const [autoDirectory, setAutoDirectory] = useState(worktreeConfig.autoDirectory);
+    const [pattern, setPattern] = useState(worktreeConfig.autoDirectoryPattern || '../{branch}');
+    const [editMode, setEditMode] = useState('menu');
+    const [tempPattern, setTempPattern] = useState(pattern);
+    useInput((input, key) => {
+        if (editMode === 'menu' &&
+            shortcutManager.matchesShortcut('cancel', input, key)) {
+            onComplete();
+        }
+    });
+    const menuItems = [
+        {
+            label: `Auto Directory: ${autoDirectory ? '✅ Enabled' : '❌ Disabled'}`,
+            value: 'toggle',
+        },
+        {
+            label: `Pattern: ${pattern}`,
+            value: 'pattern',
+        },
+        {
+            label: '💾 Save Changes',
+            value: 'save',
+        },
+        {
+            label: '← Cancel',
+            value: 'cancel',
+        },
+    ];
+    const handleMenuSelect = (item) => {
+        switch (item.value) {
+            case 'toggle':
+                setAutoDirectory(!autoDirectory);
+                break;
+            case 'pattern':
+                setTempPattern(pattern);
+                setEditMode('pattern');
+                break;
+            case 'save':
+                // Save the configuration
+                configurationManager.setWorktreeConfig({
+                    autoDirectory,
+                    autoDirectoryPattern: pattern,
+                });
+                onComplete();
+                break;
+            case 'cancel':
+                onComplete();
+                break;
+        }
+    };
+    const handlePatternSubmit = (value) => {
+        if (value.trim()) {
+            setPattern(value.trim());
+        }
+        setEditMode('menu');
+    };
+    if (editMode === 'pattern') {
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { bold: true, color: "green" }, "Configure Directory Pattern")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null, "Enter the pattern for automatic directory generation:")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { dimColor: true },
+                    "Available placeholders: ",
+                    '{branch}',
+                    " - full branch name")),
+            React.createElement(Box, null,
+                React.createElement(Text, { color: "cyan" }, '> '),
+                React.createElement(TextInput, { value: tempPattern, onChange: setTempPattern, onSubmit: handlePatternSubmit, placeholder: "../{branch}" })),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "Press Enter to save or Escape to cancel"))));
+    }
+    return (React.createElement(Box, { flexDirection: "column" },
+        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")),
+        autoDirectory && (React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, null,
+                "Example: branch \"feature/my-feature\" \u2192 directory \"",
+                pattern.replace('{branch}', 'feature-my-feature'),
+                "\""))),
+        React.createElement(SelectInput, { items: menuItems, onSelect: handleMenuSelect, isFocused: true }),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true },
+                "Press ",
+                shortcutManager.getShortcutDisplay('cancel'),
+                " to cancel without saving"))));
+};
+export default ConfigureWorktree;

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,11 +1,30 @@
-import React, { useState } from 'react';
+import React, { useState, useEffect } 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 [step, setStep] = useState('path');
+    const worktreeConfig = configurationManager.getWorktreeConfig();
+    const isAutoDirectory = worktreeConfig.autoDirectory;
+    // Adjust initial step based on auto directory mode
+    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
+    const worktreeService = new WorktreeService();
+    const branches = worktreeService.getAllBranches();
+    const defaultBranch = worktreeService.getDefaultBranch();
+    // Create branch items with default branch first
+    const branchItems = [
+        { label: `${defaultBranch} (default)`, value: defaultBranch },
+        ...branches
+            .filter(br => br !== defaultBranch)
+            .map(br => ({ label: br, value: br })),
+    ];
     useInput((input, key) => {
         if (shortcutManager.matchesShortcut('cancel', input, key)) {
             onCancel();
@@ -20,18 +39,35 @@ const NewWorktree = ({ onComplete, onCancel }) => {
     const handleBranchSubmit = (value) => {
         if (value.trim()) {
             setBranch(value.trim());
-            onComplete(path, value.trim());
+            setStep('base-branch');
         }
     };
+    const handleBaseBranchSelect = (item) => {
+        if (isAutoDirectory) {
+            // Generate path from branch name
+            const autoPath = generateWorktreeDirectory(branch, worktreeConfig.autoDirectoryPattern);
+            onComplete(autoPath, branch, item.value);
+        }
+        else {
+            onComplete(path, branch, item.value);
+        }
+    };
+    // Update generated path preview when branch changes in auto mode
+    useEffect(() => {
+        if (isAutoDirectory && branch) {
+            const autoPath = generateWorktreeDirectory(branch, worktreeConfig.autoDirectoryPattern);
+            setGeneratedPath(autoPath);
+        }
+    }, [branch, isAutoDirectory, worktreeConfig.autoDirectoryPattern]);
     return (React.createElement(Box, { flexDirection: "column" },
         React.createElement(Box, { marginBottom: 1 },
             React.createElement(Text, { bold: true, color: "green" }, "Create New Worktree")),
-        step === 'path' ? (React.createElement(Box, { flexDirection: "column" },
+        step === 'path' && !isAutoDirectory ? (React.createElement(Box, { flexDirection: "column" },
             React.createElement(Box, { marginBottom: 1 },
                 React.createElement(Text, null, "Enter worktree path (relative to repository root):")),
             React.createElement(Box, null,
                 React.createElement(Text, { color: "cyan" }, '> '),
-                React.createElement(TextInput, { value: path, onChange: setPath, onSubmit: handlePathSubmit, placeholder: "e.g., ../myproject-feature" })))) : (React.createElement(Box, { flexDirection: "column" },
+                React.createElement(TextInput, { value: path, onChange: setPath, onSubmit: handlePathSubmit, placeholder: "e.g., ../myproject-feature" })))) : step === 'branch' && !isAutoDirectory ? (React.createElement(Box, { flexDirection: "column" },
             React.createElement(Box, { marginBottom: 1 },
                 React.createElement(Text, null,
                     "Enter branch name for worktree at ",
@@ -39,7 +75,24 @@ const NewWorktree = ({ onComplete, onCancel }) => {
                     ":")),
             React.createElement(Box, null,
                 React.createElement(Text, { color: "cyan" }, '> '),
-                React.createElement(TextInput, { value: branch, onChange: setBranch, onSubmit: handleBranchSubmit, placeholder: "e.g., feature/new-feature" })))),
+                React.createElement(TextInput, { value: branch, onChange: setBranch, onSubmit: handleBranchSubmit, placeholder: "e.g., feature/new-feature" })))) : (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null, "Enter branch name (directory will be auto-generated):")),
+            React.createElement(Box, null,
+                React.createElement(Text, { color: "cyan" }, '> '),
+                React.createElement(TextInput, { value: branch, onChange: setBranch, onSubmit: handleBranchSubmit, placeholder: "e.g., feature/new-feature" })),
+            generatedPath && (React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true },
+                    "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/configurationManager.d.ts

@@ -1,4 +1,4 @@
-import { ConfigurationData, StatusHookConfig, ShortcutConfig } from '../types/index.js';
+import { ConfigurationData, StatusHookConfig, ShortcutConfig, WorktreeConfig } from '../types/index.js';
 export declare class ConfigurationManager {
     private configPath;
     private legacyShortcutsPath;
@@ -13,5 +13,7 @@ export declare class ConfigurationManager {
     setStatusHooks(hooks: StatusHookConfig): void;
     getConfiguration(): ConfigurationData;
     setConfiguration(config: ConfigurationData): void;
+    getWorktreeConfig(): WorktreeConfig;
+    setWorktreeConfig(worktreeConfig: WorktreeConfig): void;
 }
 export declare const configurationManager: ConfigurationManager;

package/dist/services/configurationManager.js

@@ -63,6 +63,11 @@ export class ConfigurationManager {
         if (!this.config.statusHooks) {
             this.config.statusHooks = {};
         }
+        if (!this.config.worktree) {
+            this.config.worktree = {
+                autoDirectory: false,
+            };
+        }
     }
     migrateLegacyShortcuts() {
         if (existsSync(this.legacyShortcutsPath)) {
@@ -111,5 +116,14 @@ export class ConfigurationManager {
         this.config = config;
         this.saveConfig();
     }
+    getWorktreeConfig() {
+        return (this.config.worktree || {
+            autoDirectory: false,
+        });
+    }
+    setWorktreeConfig(worktreeConfig) {
+        this.config.worktree = worktreeConfig;
+        this.saveConfig();
+    }
 }
 export const configurationManager = new ConfigurationManager();

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 };
@@ -179,6 +270,11 @@ export class WorktreeService {
                     cwd: sourceWorktree.path,
                     encoding: 'utf8',
                 });
+                // After rebase, merge the rebased source branch into target branch
+                execSync(`git merge --ff-only "${sourceBranch}"`, {
+                    cwd: targetWorktree.path,
+                    encoding: 'utf8',
+                });
             }
             else {
                 // Regular merge

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

@@ -47,13 +47,12 @@ export interface StatusHookConfig {
     busy?: StatusHook;
     waiting_input?: StatusHook;
 }
-export interface TerminalPadding {
-    top: number;
-    bottom: number;
+export interface WorktreeConfig {
+    autoDirectory: boolean;
+    autoDirectoryPattern?: string;
 }
-export declare const DEFAULT_TERMINAL_PADDING: TerminalPadding;
 export interface ConfigurationData {
     shortcuts?: ShortcutConfig;
     statusHooks?: StatusHookConfig;
-    terminalPadding?: TerminalPadding;
+    worktree?: WorktreeConfig;
 }

package/dist/types/index.js

@@ -2,7 +2,3 @@ export const DEFAULT_SHORTCUTS = {
     returnToMenu: { ctrl: true, key: 'e' },
     cancel: { key: 'escape' },
 };
-export const DEFAULT_TERMINAL_PADDING = {
-    top: 1,
-    bottom: 1,
-};

package/dist/utils/worktreeUtils.d.ts

@@ -0,0 +1,5 @@
+export declare function generateWorktreeDirectory(branchName: string, pattern?: string): string;
+export declare function extractBranchParts(branchName: string): {
+    prefix?: string;
+    name: string;
+};

package/dist/utils/worktreeUtils.js

@@ -0,0 +1,29 @@
+import path from 'path';
+export function generateWorktreeDirectory(branchName, pattern) {
+    // Default pattern if not specified
+    const defaultPattern = '../{branch}';
+    const activePattern = pattern || defaultPattern;
+    // Sanitize branch name for filesystem
+    // Replace slashes with dashes, remove special characters
+    const sanitizedBranch = branchName
+        .replace(/\//g, '-') // Replace forward slashes with dashes
+        .replace(/[^a-zA-Z0-9-_.]/g, '') // Remove special characters except dash, dot, underscore
+        .replace(/^-+|-+$/g, '') // Remove leading/trailing dashes
+        .toLowerCase(); // Convert to lowercase for consistency
+    // Replace placeholders in pattern
+    const directory = activePattern
+        .replace('{branch}', sanitizedBranch)
+        .replace('{branch-name}', sanitizedBranch);
+    // Ensure the path is relative to the repository root
+    return path.normalize(directory);
+}
+export function extractBranchParts(branchName) {
+    const parts = branchName.split('/');
+    if (parts.length > 1) {
+        return {
+            prefix: parts[0],
+            name: parts.slice(1).join('/'),
+        };
+    }
+    return { name: branchName };
+}

package/dist/utils/worktreeUtils.test.d.ts

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

package/dist/utils/worktreeUtils.test.js

@@ -0,0 +1,74 @@
+import { describe, it, expect } from 'vitest';
+import { generateWorktreeDirectory, extractBranchParts, } from './worktreeUtils.js';
+describe('generateWorktreeDirectory', () => {
+    describe('with default pattern', () => {
+        it('should generate directory with sanitized branch name', () => {
+            expect(generateWorktreeDirectory('feature/my-feature')).toBe('../feature-my-feature');
+            expect(generateWorktreeDirectory('bugfix/fix-123')).toBe('../bugfix-fix-123');
+            expect(generateWorktreeDirectory('release/v1.0.0')).toBe('../release-v1.0.0');
+        });
+        it('should handle branch names without slashes', () => {
+            expect(generateWorktreeDirectory('main')).toBe('../main');
+            expect(generateWorktreeDirectory('develop')).toBe('../develop');
+            expect(generateWorktreeDirectory('my-feature')).toBe('../my-feature');
+        });
+        it('should remove special characters', () => {
+            expect(generateWorktreeDirectory('feature/my@feature!')).toBe('../feature-myfeature');
+            expect(generateWorktreeDirectory('bugfix/#123')).toBe('../bugfix-123');
+            expect(generateWorktreeDirectory('release/v1.0.0-beta')).toBe('../release-v1.0.0-beta');
+        });
+        it('should handle edge cases', () => {
+            expect(generateWorktreeDirectory('//feature//')).toBe('../feature');
+            expect(generateWorktreeDirectory('-feature-')).toBe('../feature');
+            expect(generateWorktreeDirectory('FEATURE/UPPERCASE')).toBe('../feature-uppercase');
+        });
+    });
+    describe('with custom patterns', () => {
+        it('should use custom pattern with {branch} placeholder', () => {
+            expect(generateWorktreeDirectory('feature/my-feature', '../worktrees/{branch}')).toBe('../worktrees/feature-my-feature');
+            expect(generateWorktreeDirectory('bugfix/123', '/tmp/{branch}-wt')).toBe('/tmp/bugfix-123-wt');
+        });
+        it('should handle patterns without placeholders', () => {
+            expect(generateWorktreeDirectory('feature/test', '../fixed-directory')).toBe('../fixed-directory');
+        });
+        it('should normalize paths', () => {
+            expect(generateWorktreeDirectory('feature/test', '../foo/../bar/{branch}')).toBe('../bar/feature-test');
+            expect(generateWorktreeDirectory('feature/test', './worktrees/{branch}')).toBe('worktrees/feature-test');
+        });
+    });
+});
+describe('extractBranchParts', () => {
+    it('should extract prefix and name from branch with slash', () => {
+        expect(extractBranchParts('feature/my-feature')).toEqual({
+            prefix: 'feature',
+            name: 'my-feature',
+        });
+        expect(extractBranchParts('bugfix/fix-123')).toEqual({
+            prefix: 'bugfix',
+            name: 'fix-123',
+        });
+    });
+    it('should handle branches with multiple slashes', () => {
+        expect(extractBranchParts('feature/user/profile-page')).toEqual({
+            prefix: 'feature',
+            name: 'user/profile-page',
+        });
+        expect(extractBranchParts('release/v1.0/final')).toEqual({
+            prefix: 'release',
+            name: 'v1.0/final',
+        });
+    });
+    it('should handle branches without slashes', () => {
+        expect(extractBranchParts('main')).toEqual({
+            name: 'main',
+        });
+        expect(extractBranchParts('develop')).toEqual({
+            name: 'develop',
+        });
+    });
+    it('should handle empty branch name', () => {
+        expect(extractBranchParts('')).toEqual({
+            name: '',
+        });
+    });
+});

package/package.json

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