ccmanager 2.2.4 → 2.4.0

package/dist/components/App.js

@@ -277,7 +277,7 @@ const App = ({ devcontainerConfig, multiProject }) => {
                 React.createElement(Text, { color: "red" },
                     "Error: ",
                     error))),
-            React.createElement(NewWorktree, { onComplete: handleCreateWorktree, onCancel: handleCancelNewWorktree })));
+            React.createElement(NewWorktree, { projectPath: selectedProject?.path || process.cwd(), onComplete: handleCreateWorktree, onCancel: handleCancelNewWorktree })));
     }
     if (view === 'creating-worktree') {
         return (React.createElement(Box, { flexDirection: "column" },

package/dist/components/ConfigureWorktree.js

@@ -4,6 +4,7 @@ import SelectInput from 'ink-select-input';
 import TextInputWrapper from './TextInputWrapper.js';
 import { configurationManager } from '../services/configurationManager.js';
 import { shortcutManager } from '../services/shortcutManager.js';
+import { generateWorktreeDirectory } from '../utils/worktreeUtils.js';
 const ConfigureWorktree = ({ onComplete }) => {
     const worktreeConfig = configurationManager.getWorktreeConfig();
     const [autoDirectory, setAutoDirectory] = useState(worktreeConfig.autoDirectory);
@@ -11,6 +12,9 @@ const ConfigureWorktree = ({ onComplete }) => {
     const [copySessionData, setCopySessionData] = useState(worktreeConfig.copySessionData ?? true);
     const [editMode, setEditMode] = useState('menu');
     const [tempPattern, setTempPattern] = useState(pattern);
+    // Example values for preview
+    const exampleProjectPath = '/home/user/src/myproject';
+    const exampleBranchName = 'feature/my-feature';
     useInput((input, key) => {
         if (editMode === 'menu' &&
             shortcutManager.matchesShortcut('cancel', input, key)) {
@@ -81,7 +85,10 @@ const ConfigureWorktree = ({ onComplete }) => {
                 React.createElement(Text, { dimColor: true },
                     "Available placeholders: ",
                     '{branch}',
-                    " - full branch name")),
+                    " - full branch name,",
+                    ' ',
+                    '{project}',
+                    " - repository name")),
             React.createElement(Box, null,
                 React.createElement(Text, { color: "cyan" }, '> '),
                 React.createElement(TextInputWrapper, { value: tempPattern, onChange: setTempPattern, onSubmit: handlePatternSubmit, placeholder: "../{branch}" })),
@@ -95,8 +102,12 @@ const ConfigureWorktree = ({ onComplete }) => {
             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 \"",
-                pattern.replace('{branch}', 'feature-my-feature'),
+                "Example: project \"",
+                exampleProjectPath,
+                "\", branch \"",
+                exampleBranchName,
+                "\" \u2192 directory \"",
+                generateWorktreeDirectory(exampleProjectPath, exampleBranchName, pattern),
                 "\""))),
         React.createElement(SelectInput, { items: menuItems, onSelect: handleMenuSelect, isFocused: true }),
         React.createElement(Box, { marginTop: 1 },

package/dist/components/NewWorktree.d.ts

@@ -1,5 +1,6 @@
 import React from 'react';
 interface NewWorktreeProps {
+    projectPath?: string;
     onComplete: (path: string, branch: string, baseBranch: string, copySessionData: boolean, copyClaudeDirectory: boolean) => void;
     onCancel: () => void;
 }

package/dist/components/NewWorktree.js

@@ -7,7 +7,7 @@ import { configurationManager } from '../services/configurationManager.js';
 import { generateWorktreeDirectory } from '../utils/worktreeUtils.js';
 import { WorktreeService } from '../services/worktreeService.js';
 import { useSearchMode } from '../hooks/useSearchMode.js';
-const NewWorktree = ({ onComplete, onCancel }) => {
+const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
     const worktreeConfig = configurationManager.getWorktreeConfig();
     const isAutoDirectory = worktreeConfig.autoDirectory;
     const limit = 10;
@@ -81,7 +81,7 @@ const NewWorktree = ({ onComplete, onCancel }) => {
         setCopySessionData(shouldCopy);
         if (isAutoDirectory) {
             // Generate path from branch name
-            const autoPath = generateWorktreeDirectory(branch, worktreeConfig.autoDirectoryPattern);
+            const autoPath = generateWorktreeDirectory(projectPath || process.cwd(), branch, worktreeConfig.autoDirectoryPattern);
             onComplete(autoPath, branch, baseBranch, shouldCopy, copyClaudeDirectory);
         }
         else {
@@ -91,9 +91,14 @@ const NewWorktree = ({ onComplete, onCancel }) => {
     // Calculate generated path for preview (memoized to avoid expensive recalculations)
     const generatedPath = useMemo(() => {
         return isAutoDirectory && branch
-            ? generateWorktreeDirectory(branch, worktreeConfig.autoDirectoryPattern)
+            ? generateWorktreeDirectory(projectPath || process.cwd(), branch, worktreeConfig.autoDirectoryPattern)
             : '';
-    }, [isAutoDirectory, branch, worktreeConfig.autoDirectoryPattern]);
+    }, [
+        isAutoDirectory,
+        branch,
+        worktreeConfig.autoDirectoryPattern,
+        projectPath,
+    ]);
     return (React.createElement(Box, { flexDirection: "column" },
         React.createElement(Box, { marginBottom: 1 },
             React.createElement(Text, { bold: true, color: "green" }, "Create New Worktree")),

package/dist/services/stateDetector.js

@@ -76,13 +76,13 @@ export class CodexStateDetector extends BaseStateDetector {
         const content = this.getTerminalContent(terminal);
         const lowerContent = content.toLowerCase();
         // Check for waiting prompts
-        if (content.includes('│Allow') ||
-            content.includes('[y/N]') ||
-            content.includes('Press any key')) {
+        if (lowerContent.includes('allow command?') ||
+            lowerContent.includes('[y/n]') ||
+            lowerContent.includes('yes (y)')) {
             return 'waiting_input';
         }
         // Check for busy state
-        if (lowerContent.includes('press esc')) {
+        if (/esc.*interrupt/i.test(lowerContent)) {
             return 'busy';
         }
         // Otherwise idle

package/dist/services/stateDetector.test.js

@@ -295,38 +295,38 @@ describe('CodexStateDetector', () => {
     beforeEach(() => {
         detector = new CodexStateDetector();
     });
-    it('should detect waiting_input state for │Allow pattern', () => {
+    it('should detect waiting_input state for Allow command? pattern', () => {
         // Arrange
-        terminal = createMockTerminal(['Some output', '│Allow execution?', '│ > ']);
+        terminal = createMockTerminal(['Some output', 'Allow command?', '│ > ']);
         // Act
         const state = detector.detectState(terminal, 'idle');
         // Assert
         expect(state).toBe('waiting_input');
     });
-    it('should detect waiting_input state for [y/N] pattern', () => {
+    it('should detect waiting_input state for [y/n] pattern', () => {
         // Arrange
-        terminal = createMockTerminal(['Some output', 'Continue? [y/N]', '> ']);
+        terminal = createMockTerminal(['Some output', 'Continue? [y/n]', '> ']);
         // Act
         const state = detector.detectState(terminal, 'idle');
         // Assert
         expect(state).toBe('waiting_input');
     });
-    it('should detect waiting_input state for Press any key pattern', () => {
+    it('should detect waiting_input state for yes (y) pattern', () => {
         // Arrange
         terminal = createMockTerminal([
             'Some output',
-            'Press any key to continue...',
+            'Apply changes? yes (y) / no (n)',
         ]);
         // Act
         const state = detector.detectState(terminal, 'idle');
         // Assert
         expect(state).toBe('waiting_input');
     });
-    it('should detect busy state for press esc pattern', () => {
+    it('should detect busy state for Esc to interrupt pattern', () => {
         // Arrange
         terminal = createMockTerminal([
             'Processing...',
-            'press esc to cancel',
+            'Esc to interrupt',
             'Working...',
         ]);
         // Act
@@ -334,11 +334,11 @@ describe('CodexStateDetector', () => {
         // Assert
         expect(state).toBe('busy');
     });
-    it('should detect busy state for PRESS ESC (uppercase)', () => {
+    it('should detect busy state for ESC INTERRUPT (uppercase)', () => {
         // Arrange
         terminal = createMockTerminal([
             'Processing...',
-            'PRESS ESC to stop',
+            'PRESS ESC TO INTERRUPT',
             'Working...',
         ]);
         // Act
@@ -356,7 +356,7 @@ describe('CodexStateDetector', () => {
     });
     it('should prioritize waiting_input over busy', () => {
         // Arrange
-        terminal = createMockTerminal(['press esc to cancel', '[y/N]']);
+        terminal = createMockTerminal(['press esc to interrupt', '[y/n]']);
         // Act
         const state = detector.detectState(terminal, 'idle');
         // Assert

package/dist/utils/hookExecutor.test.js

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi } from 'vitest';
 import { executeHook, executeWorktreePostCreationHook, executeStatusHook, } from './hookExecutor.js';
-import { mkdtemp, rm, readFile } from 'fs/promises';
+import { mkdtemp, rm, readFile, realpath } from 'fs/promises';
 import { tmpdir } from 'os';
 import { join } from 'path';
 import { configurationManager } from '../services/configurationManager.js';
@@ -137,7 +137,9 @@ describe('hookExecutor Integration Tests', () => {
                 const { readFile } = await import('fs/promises');
                 const output = await readFile(outputFile, 'utf-8');
                 // Assert - should be executed in tmpDir
-                expect(output.trim()).toBe(tmpDir);
+                const expectedPath = await realpath(tmpDir);
+                const actualPath = await realpath(output.trim());
+                expect(actualPath).toBe(expectedPath);
             }
             finally {
                 // Cleanup
@@ -182,7 +184,10 @@ describe('hookExecutor Integration Tests', () => {
                 const { readFile } = await import('fs/promises');
                 const output = await readFile(outputFile, 'utf-8');
                 // Assert - should be executed in worktree path, not git root
-                expect(output.trim()).toBe(tmpDir);
+                const expectedPath = await realpath(tmpDir);
+                const actualPath = await realpath(output.trim());
+                expect(actualPath).toBe(expectedPath);
+                // Also verify it's not the git root path
                 expect(output.trim()).not.toBe(gitRoot);
             }
             finally {

package/dist/utils/worktreeUtils.d.ts

@@ -18,7 +18,7 @@ interface WorktreeItem {
     };
 }
 export declare function truncateString(str: string, maxLength: number): string;
-export declare function generateWorktreeDirectory(branchName: string, pattern?: string): string;
+export declare function generateWorktreeDirectory(projectPath: string, branchName: string, pattern?: string): string;
 export declare function extractBranchParts(branchName: string): {
     prefix?: string;
     name: string;

package/dist/utils/worktreeUtils.js

@@ -1,4 +1,5 @@
 import path from 'path';
+import { execSync } from 'child_process';
 import stripAnsi from 'strip-ansi';
 import { getStatusDisplay } from '../constants/statusIcons.js';
 import { formatGitFileChanges, formatGitAheadBehind, formatParentBranch, } from './gitStatus.js';
@@ -11,21 +12,46 @@ export function truncateString(str, maxLength) {
         return str;
     return str.substring(0, maxLength - 3) + '...';
 }
-export function generateWorktreeDirectory(branchName, pattern) {
+function getGitRepositoryName(projectPath) {
+    try {
+        const gitCommonDir = execSync('git rev-parse --git-common-dir', {
+            cwd: projectPath,
+            encoding: 'utf8',
+        }).trim();
+        const absoluteGitCommonDir = path.isAbsolute(gitCommonDir)
+            ? gitCommonDir
+            : path.resolve(projectPath, gitCommonDir);
+        const mainWorkingDir = path.dirname(absoluteGitCommonDir);
+        return path.basename(mainWorkingDir);
+    }
+    catch {
+        return path.basename(projectPath);
+    }
+}
+export function generateWorktreeDirectory(projectPath, 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);
+    let sanitizedBranch;
+    let projectName;
+    const directory = activePattern.replace(/{(\w+)}/g, (placeholder, name) => {
+        switch (name) {
+            case 'branch':
+            case 'branch-name':
+                // Sanitize branch name for filesystem
+                sanitizedBranch ?? (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
+                return sanitizedBranch;
+            case 'project':
+                projectName ?? (projectName = getGitRepositoryName(projectPath));
+                return projectName;
+            default:
+                return placeholder;
+        }
+    });
     // Ensure the path is relative to the repository root
     return path.normalize(directory);
 }

package/dist/utils/worktreeUtils.test.js

@@ -1,39 +1,62 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { generateWorktreeDirectory, extractBranchParts, truncateString, prepareWorktreeItems, calculateColumnPositions, assembleWorktreeLabel, } from './worktreeUtils.js';
+import { execSync } from 'child_process';
+// Mock child_process module
+vi.mock('child_process');
 describe('generateWorktreeDirectory', () => {
+    const mockedExecSync = vi.mocked(execSync);
+    const projectPath = '/home/user/src/myproject';
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
     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');
+            expect(generateWorktreeDirectory(projectPath, 'feature/my-feature')).toBe('../feature-my-feature');
+            expect(generateWorktreeDirectory(projectPath, 'bugfix/fix-123')).toBe('../bugfix-fix-123');
+            expect(generateWorktreeDirectory(projectPath, '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');
+            expect(generateWorktreeDirectory(projectPath, 'main')).toBe('../main');
+            expect(generateWorktreeDirectory(projectPath, 'develop')).toBe('../develop');
+            expect(generateWorktreeDirectory(projectPath, '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');
+            expect(generateWorktreeDirectory(projectPath, 'feature/my@feature!')).toBe('../feature-myfeature');
+            expect(generateWorktreeDirectory(projectPath, 'bugfix/#123')).toBe('../bugfix-123');
+            expect(generateWorktreeDirectory(projectPath, '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');
+            expect(generateWorktreeDirectory(projectPath, '//feature//')).toBe('../feature');
+            expect(generateWorktreeDirectory(projectPath, '-feature-')).toBe('../feature');
+            expect(generateWorktreeDirectory(projectPath, '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');
+            expect(generateWorktreeDirectory(projectPath, 'feature/my-feature', '../worktrees/{branch}')).toBe('../worktrees/feature-my-feature');
+            expect(generateWorktreeDirectory(projectPath, 'bugfix/123', '/tmp/{branch}-wt')).toBe('/tmp/bugfix-123-wt');
+        });
+        it('should use git repository name when in main working directory', () => {
+            mockedExecSync.mockReturnValue('.git');
+            expect(generateWorktreeDirectory('/home/user/src/main-repo', 'feature/test', '../worktrees/{project}-{branch}')).toBe('../worktrees/main-repo-feature-test');
+        });
+        it('should use git repository name when git command succeeds (worktree case)', () => {
+            mockedExecSync.mockReturnValue('/home/user/src/main-repo/.git');
+            expect(generateWorktreeDirectory('/home/user/src/worktree-branch', 'feature/test', '../worktrees/{project}-{branch}')).toBe('../worktrees/main-repo-feature-test');
+        });
+        it('should use custom pattern with {project} placeholder (fallback case)', () => {
+            mockedExecSync.mockImplementation(() => {
+                throw new Error('fatal: not a git repository (or any of the parent directories): .git');
+            });
+            expect(generateWorktreeDirectory('/home/user/src/myproject', 'feature/test', '../worktrees/{project}-{branch}')).toBe('../worktrees/myproject-feature-test');
+            expect(generateWorktreeDirectory('/home/user/src/foo', 'main', '/tmp/{project}')).toBe('/tmp/foo');
         });
         it('should handle patterns without placeholders', () => {
-            expect(generateWorktreeDirectory('feature/test', '../fixed-directory')).toBe('../fixed-directory');
+            expect(generateWorktreeDirectory(projectPath, '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');
+            expect(generateWorktreeDirectory(projectPath, 'feature/test', '../foo/../bar/{branch}')).toBe('../bar/feature-test');
+            expect(generateWorktreeDirectory(projectPath, 'feature/test', './worktrees/{branch}')).toBe('worktrees/feature-test');
         });
     });
 });

package/package.json

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