ccmanager 3.11.1 → 3.11.2

package/dist/components/App.js

@@ -14,7 +14,8 @@ import RemoteBranchSelector from './RemoteBranchSelector.js';
 import LoadingSpinner from './LoadingSpinner.js';
 import { globalSessionOrchestrator } from '../services/globalSessionOrchestrator.js';
 import { WorktreeService } from '../services/worktreeService.js';
-import { worktreeNameGenerator } from '../services/worktreeNameGenerator.js';
+import { worktreeNameGenerator, generateFallbackBranchName, } from '../services/worktreeNameGenerator.js';
+import { logger } from '../utils/logger.js';
 import { AmbiguousBranchError, } from '../types/index.js';
 import { configReader } from '../services/config/configReader.js';
 import { ENV_VARS } from '../constants/env.js';
@@ -327,11 +328,12 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
             const existingBranches = allBranches._tag === 'Right' ? allBranches.right : [];
             const generatedBranch = await Effect.runPromise(Effect.either(worktreeNameGenerator.generateBranchNameEffect(request.initialPrompt, request.baseBranch, existingBranches)));
             if (generatedBranch._tag === 'Left') {
-                setError(formatErrorMessage(generatedBranch.left));
-                setView('new-worktree');
-                return;
+                logger.warn(`Branch name generation failed, using fallback: ${formatErrorMessage(generatedBranch.left)}`);
+                branch = generateFallbackBranchName(existingBranches);
+            }
+            else {
+                branch = generatedBranch.right;
             }
-            branch = generatedBranch.right;
             if (request.autoDirectoryPattern) {
                 targetPath = generateWorktreeDirectory(request.projectPath, branch, request.autoDirectoryPattern);
             }

package/dist/components/Dashboard.js

@@ -11,7 +11,7 @@ import { WorktreeService } from '../services/worktreeService.js';
 import { STATUS_ICONS, STATUS_LABELS, MENU_ICONS, getStatusDisplay, } from '../constants/statusIcons.js';
 import { useSearchMode } from '../hooks/useSearchMode.js';
 import { useGitStatus } from '../hooks/useGitStatus.js';
-import { truncateString, calculateColumnPositions, assembleWorktreeLabel, } from '../utils/worktreeUtils.js';
+import { truncateString, calculateColumnPositions, assembleWorktreeLabel, formatRelativeDate, } from '../utils/worktreeUtils.js';
 import { formatGitFileChanges, formatGitAheadBehind, formatParentBranch, } from '../utils/gitStatus.js';
 import TextInputWrapper from './TextInputWrapper.js';
 const MAX_BRANCH_NAME_LENGTH = 70;
@@ -241,12 +241,18 @@ const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, error, onDis
                     fileChanges,
                     aheadBehind,
                     parentBranch,
+                    lastCommitDate: wt.lastCommitDate
+                        ? `\x1b[90m${formatRelativeDate(wt.lastCommitDate)}\x1b[0m`
+                        : '',
                     error: itemError,
                     lengths: {
                         base: stripAnsi(baseLabel).length,
                         fileChanges: stripAnsi(fileChanges).length,
                         aheadBehind: stripAnsi(aheadBehind).length,
                         parentBranch: stripAnsi(parentBranch).length,
+                        lastCommitDate: wt.lastCommitDate
+                            ? formatRelativeDate(wt.lastCommitDate).length
+                            : 0,
                     },
                 };
             });

package/dist/components/DeleteWorktree.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState, useEffect } from 'react';
+import path from 'path';
 import { Box, Text, useInput } from 'ink';
 import SelectInput from 'ink-select-input';
 import { Effect } from 'effect';
@@ -20,8 +21,18 @@ const DeleteWorktree = ({ projectPath, onComplete, onCancel, }) => {
             try {
                 const allWorktrees = await Effect.runPromise(worktreeService.getWorktreesEffect());
                 if (!cancelled) {
-                    // Filter out main worktree - we shouldn't delete it
-                    const deletableWorktrees = allWorktrees.filter(wt => !wt.isMainWorktree);
+                    // Filter out main worktree and current working directory worktree
+                    const resolvedCwd = path.resolve(process.cwd());
+                    const deletableWorktrees = allWorktrees.filter(wt => {
+                        if (wt.isMainWorktree)
+                            return false;
+                        const resolvedPath = path.resolve(wt.path);
+                        if (resolvedCwd === resolvedPath ||
+                            resolvedCwd.startsWith(resolvedPath + path.sep)) {
+                            return false;
+                        }
+                        return true;
+                    });
                     setWorktrees(deletableWorktrees);
                     setIsLoading(false);
                 }

package/dist/components/Menu.js

@@ -144,7 +144,8 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
                 sessionManager.isAutoApprovalDisabledForWorktree(item.worktree.path);
             const label = baseLabel + (aaDisabled ? ' [Auto Approval Off]' : '');
             // Only show numbers for worktrees (0-9) when not in search mode
-            const numberPrefix = !isSearchMode && index < 10 ? `${index} ❯ ` : '❯ ';
+            // Use fixed-width prefix to prevent flicker at scroll boundary
+            const numberPrefix = !isSearchMode && index < 10 ? `${index} ❯ ` : '  ❯ ';
             return {
                 type: 'worktree',
                 label: numberPrefix + label,

package/dist/services/worktreeNameGenerator.d.ts

@@ -2,6 +2,7 @@ import { Effect } from 'effect';
 import { ProcessError } from '../types/errors.js';
 export declare const extractBranchNameFromOutput: (stdout: string) => string;
 export declare const deduplicateBranchName: (name: string, existingBranches: string[]) => string;
+export declare const generateFallbackBranchName: (existingBranches?: string[]) => string;
 export declare class WorktreeNameGenerator {
     generateBranchNameEffect(userPrompt: string, baseBranch: string, existingBranches?: string[]): Effect.Effect<string, ProcessError, never>;
 }

package/dist/services/worktreeNameGenerator.js

@@ -1,3 +1,4 @@
+import { randomBytes } from 'crypto';
 import { Effect } from 'effect';
 import { execFile } from 'child_process';
 import { ProcessError } from '../types/errors.js';
@@ -121,6 +122,15 @@ export const deduplicateBranchName = (name, existingBranches) => {
         }
     }
 };
+export const generateFallbackBranchName = (existingBranches) => {
+    const date = new Date();
+    const dateStr = `${date.getFullYear()}${String(date.getMonth() + 1).padStart(2, '0')}${String(date.getDate()).padStart(2, '0')}`;
+    const randomSuffix = randomBytes(3).toString('hex');
+    const name = `${dateStr}-${randomSuffix}`;
+    return existingBranches
+        ? deduplicateBranchName(name, existingBranches)
+        : name;
+};
 export class WorktreeNameGenerator {
     generateBranchNameEffect(userPrompt, baseBranch, existingBranches) {
         return Effect.tryPromise({

package/dist/services/worktreeNameGenerator.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { deduplicateBranchName, extractBranchNameFromOutput, worktreeNameGenerator as generator, } from './worktreeNameGenerator.js';
+import { deduplicateBranchName, extractBranchNameFromOutput, generateFallbackBranchName, worktreeNameGenerator as generator, } from './worktreeNameGenerator.js';
 describe('WorktreeNameGenerator output parsing', () => {
     it('normalizes direct json branchName responses', async () => {
         const value = extractBranchNameFromOutput('{"branchName":"feature/add prompt"}');
@@ -33,3 +33,15 @@ describe('deduplicateBranchName', () => {
         expect(deduplicateBranchName('Feature/New', ['feature/new'])).toBe('Feature/New-2');
     });
 });
+describe('generateFallbackBranchName', () => {
+    it('returns a name matching YYYYMMDD-hex pattern', () => {
+        const name = generateFallbackBranchName();
+        expect(name).toMatch(/^\d{8}-[0-9a-f]{6}$/);
+    });
+    it('deduplicates against existing branches', () => {
+        const first = generateFallbackBranchName();
+        const name = generateFallbackBranchName([first]);
+        // Either it's different (random collision unlikely) or it has a -2 suffix
+        expect(name).not.toBe(first);
+    });
+});

package/dist/services/worktreeService.js

@@ -662,6 +662,21 @@ export class WorktreeService {
                 if (mainWorktree && mainWorktree.path.includes('.git/modules')) {
                     mainWorktree.path = self.gitRootPath;
                 }
+                // Fetch last commit date for each worktree
+                for (const wt of worktrees) {
+                    try {
+                        const dateStr = execSync('git log -1 --format=%aI', {
+                            cwd: wt.path,
+                            encoding: 'utf8',
+                        }).trim();
+                        if (dateStr) {
+                            wt.lastCommitDate = new Date(dateStr);
+                        }
+                    }
+                    catch {
+                        // Ignore errors (e.g., empty repo)
+                    }
+                }
                 // Sort worktrees by last session if requested
                 if (sortByLastSession) {
                     worktrees.sort((a, b) => {
@@ -900,6 +915,17 @@ export class WorktreeService {
                     stderr: 'Cannot delete the main worktree',
                 }));
             }
+            // Prevent deleting the worktree that contains the current working directory
+            const resolvedWorktreePath = path.resolve(worktreePath);
+            const resolvedCwd = path.resolve(process.cwd());
+            if (resolvedCwd === resolvedWorktreePath ||
+                resolvedCwd.startsWith(resolvedWorktreePath + path.sep)) {
+                return yield* Effect.fail(new GitError({
+                    command: 'git worktree remove',
+                    exitCode: 1,
+                    stderr: `Cannot delete the worktree at "${worktreePath}" because it is the current working directory`,
+                }));
+            }
             // Remove the worktree
             yield* Effect.try({
                 try: () => {

package/dist/services/worktreeService.test.js

@@ -757,6 +757,36 @@ branch refs/heads/main
                 expect.fail('Should have returned Left with GitError');
             }
         });
+        it('should return Effect that fails with GitError when trying to delete worktree matching cwd', async () => {
+            const cwdPath = process.cwd();
+            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 ${cwdPath}
+HEAD efgh5678
+branch refs/heads/feature
+`;
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const effect = service.deleteWorktreeEffect(cwdPath);
+            const result = await Effect.runPromise(Effect.either(effect));
+            if (result._tag === 'Left') {
+                expect(result.left).toBeInstanceOf(GitError);
+                expect(result.left.stderr).toContain('because it is the current working directory');
+            }
+            else {
+                expect.fail('Should have returned Left with GitError');
+            }
+        });
     });
     describe('Effect-based mergeWorktree', () => {
         it('should return Effect with void on successful merge', async () => {

package/dist/types/index.d.ts

@@ -13,6 +13,7 @@ export interface Worktree {
     hasSession: boolean;
     gitStatus?: GitStatus;
     gitStatusError?: string;
+    lastCommitDate?: Date;
 }
 export interface Session {
     id: string;

package/dist/utils/worktreeUtils.d.ts

@@ -9,14 +9,20 @@ export interface WorktreeItem {
     fileChanges: string;
     aheadBehind: string;
     parentBranch: string;
+    lastCommitDate: string;
     error?: string;
     lengths: {
         base: number;
         fileChanges: number;
         aheadBehind: number;
         parentBranch: number;
+        lastCommitDate: number;
     };
 }
+/**
+ * Format a date as a relative time string (e.g., "2h ago", "3d ago").
+ */
+export declare function formatRelativeDate(date: Date): string;
 export declare function truncateString(str: string, maxLength: number): string;
 export declare function generateWorktreeDirectory(projectPath: string, branchName: string, pattern?: string): string;
 export declare function extractBranchParts(branchName: string): {
@@ -34,6 +40,7 @@ export declare function calculateColumnPositions(items: WorktreeItem[]): {
     fileChanges: number;
     aheadBehind: number;
     parentBranch: number;
+    lastCommitDate: number;
 };
 /**
  * Assembles the final worktree label with proper column alignment

package/dist/utils/worktreeUtils.js

@@ -6,6 +6,33 @@ import { formatGitFileChanges, formatGitAheadBehind, formatParentBranch, } from
 // Constants
 const MAX_BRANCH_NAME_LENGTH = 70; // Maximum characters for branch name display
 const MIN_COLUMN_PADDING = 2; // Minimum spaces between columns
+/**
+ * Format a date as a relative time string (e.g., "2h ago", "3d ago").
+ */
+export function formatRelativeDate(date) {
+    const now = Date.now();
+    const diffMs = now - date.getTime();
+    const diffSec = Math.floor(diffMs / 1000);
+    const diffMin = Math.floor(diffSec / 60);
+    const diffHour = Math.floor(diffMin / 60);
+    const diffDay = Math.floor(diffHour / 24);
+    const diffWeek = Math.floor(diffDay / 7);
+    const diffMonth = Math.floor(diffDay / 30);
+    const diffYear = Math.floor(diffDay / 365);
+    if (diffYear > 0)
+        return `${diffYear}y ago`;
+    if (diffMonth > 0)
+        return `${diffMonth}mo ago`;
+    if (diffWeek > 0)
+        return `${diffWeek}w ago`;
+    if (diffDay > 0)
+        return `${diffDay}d ago`;
+    if (diffHour > 0)
+        return `${diffHour}h ago`;
+    if (diffMin > 0)
+        return `${diffMin}m ago`;
+    return 'just now';
+}
 // Utility function to truncate strings with ellipsis
 export function truncateString(str, maxLength) {
     if (str.length <= maxLength)
@@ -107,6 +134,10 @@ export function prepareWorktreeItems(worktrees, sessions) {
             // Show fetching status in dim gray
             fileChanges = '\x1b[90m[fetching...]\x1b[0m';
         }
+        // Format last commit date as dim relative time
+        const lastCommitDate = wt.lastCommitDate
+            ? `\x1b[90m${formatRelativeDate(wt.lastCommitDate)}\x1b[0m`
+            : '';
         return {
             worktree: wt,
             session,
@@ -114,12 +145,14 @@ export function prepareWorktreeItems(worktrees, sessions) {
             fileChanges,
             aheadBehind,
             parentBranch,
+            lastCommitDate,
             error,
             lengths: {
                 base: stripAnsi(baseLabel).length,
                 fileChanges: stripAnsi(fileChanges).length,
                 aheadBehind: stripAnsi(aheadBehind).length,
                 parentBranch: stripAnsi(parentBranch).length,
+                lastCommitDate: stripAnsi(lastCommitDate).length,
             },
         };
     });
@@ -132,6 +165,7 @@ export function calculateColumnPositions(items) {
     let maxBranchLength = 0;
     let maxFileChangesLength = 0;
     let maxAheadBehindLength = 0;
+    let maxParentBranchLength = 0;
     items.forEach(item => {
         // Skip items with errors for alignment calculation
         if (item.error)
@@ -139,15 +173,18 @@ export function calculateColumnPositions(items) {
         maxBranchLength = Math.max(maxBranchLength, item.lengths.base);
         maxFileChangesLength = Math.max(maxFileChangesLength, item.lengths.fileChanges);
         maxAheadBehindLength = Math.max(maxAheadBehindLength, item.lengths.aheadBehind);
+        maxParentBranchLength = Math.max(maxParentBranchLength, item.lengths.parentBranch);
     });
     // Simple column positioning
     const fileChangesColumn = maxBranchLength + MIN_COLUMN_PADDING;
     const aheadBehindColumn = fileChangesColumn + maxFileChangesLength + MIN_COLUMN_PADDING + 2;
     const parentBranchColumn = aheadBehindColumn + maxAheadBehindLength + MIN_COLUMN_PADDING + 2;
+    const lastCommitDateColumn = parentBranchColumn + maxParentBranchLength + MIN_COLUMN_PADDING + 2;
     return {
         fileChanges: fileChangesColumn,
         aheadBehind: aheadBehindColumn,
         parentBranch: parentBranchColumn,
+        lastCommitDate: lastCommitDateColumn,
     };
 }
 // Pad string to column position
@@ -175,6 +212,11 @@ export function assembleWorktreeLabel(item, columns) {
     if (item.parentBranch) {
         label =
             padTo(label, currentLength, columns.parentBranch) + item.parentBranch;
+        currentLength = columns.parentBranch + item.lengths.parentBranch;
+    }
+    if (item.lastCommitDate) {
+        label =
+            padTo(label, currentLength, columns.lastCommitDate) + item.lastCommitDate;
     }
     return label;
 }

package/dist/utils/worktreeUtils.test.js

@@ -170,11 +170,13 @@ describe('column alignment', () => {
             fileChanges: '\x1b[32m+10\x1b[0m \x1b[31m-5\x1b[0m',
             aheadBehind: '\x1b[33m↑2 ↓3\x1b[0m',
             parentBranch: '',
+            lastCommitDate: '',
             lengths: {
                 base: 19, // 'feature/test-branch'.length
                 fileChanges: 6, // '+10 -5'.length
                 aheadBehind: 5, // '↑2 ↓3'.length
                 parentBranch: 0,
+                lastCommitDate: 0,
             },
         },
         {
@@ -183,11 +185,13 @@ describe('column alignment', () => {
             fileChanges: '\x1b[32m+2\x1b[0m \x1b[31m-1\x1b[0m',
             aheadBehind: '\x1b[33m↑1\x1b[0m',
             parentBranch: '',
+            lastCommitDate: '',
             lengths: {
                 base: 4, // 'main'.length
                 fileChanges: 5, // '+2 -1'.length
                 aheadBehind: 2, // '↑1'.length
                 parentBranch: 0,
+                lastCommitDate: 0,
             },
         },
     ];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "3.11.1",
+	"version": "3.11.2",
 	"description": "TUI application for managing multiple Claude Code sessions across Git worktrees",
 	"license": "MIT",
 	"author": "Kodai Kabasawa",
@@ -41,11 +41,11 @@
 		"bin"
 	],
 	"optionalDependencies": {
-		"@kodaikabasawa/ccmanager-darwin-arm64": "3.11.1",
-		"@kodaikabasawa/ccmanager-darwin-x64": "3.11.1",
-		"@kodaikabasawa/ccmanager-linux-arm64": "3.11.1",
-		"@kodaikabasawa/ccmanager-linux-x64": "3.11.1",
-		"@kodaikabasawa/ccmanager-win32-x64": "3.11.1"
+		"@kodaikabasawa/ccmanager-darwin-arm64": "3.11.2",
+		"@kodaikabasawa/ccmanager-darwin-x64": "3.11.2",
+		"@kodaikabasawa/ccmanager-linux-arm64": "3.11.2",
+		"@kodaikabasawa/ccmanager-linux-x64": "3.11.2",
+		"@kodaikabasawa/ccmanager-win32-x64": "3.11.2"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",