ccmanager 4.1.20 → 4.1.22

package/dist/components/Dashboard.js

@@ -245,6 +245,7 @@ const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, onSessionAct
                     worktree: wt,
                     session: entry.session,
                     baseLabel,
+                    searchableName: `${entry.projectName} :: ${fullBranchName}${isMain}`,
                     fileChanges,
                     aheadBehind,
                     parentBranch,

package/dist/components/Menu.js

@@ -10,7 +10,7 @@ import { prepareSessionItems, calculateColumnPositions, assembleSessionLabel, }
 import { projectManager } from '../services/projectManager.js';
 import { useSearchMode } from '../hooks/useSearchMode.js';
 import { useDynamicLimit } from '../hooks/useDynamicLimit.js';
-import { filterWorktreesByQuery } from '../utils/filterByQuery.js';
+import { filterSessionItemsByQuery } from '../utils/filterByQuery.js';
 import SearchableList from './SearchableList.js';
 import { globalSessionOrchestrator } from '../services/globalSessionOrchestrator.js';
 import { configReader } from '../services/config/configReader.js';
@@ -124,10 +124,9 @@ const Menu = ({ sessionManager, worktreeService, onMenuAction, onSelectRecentPro
             sortByLastSession: worktreeConfig.sortByLastSession,
         });
         const columnPositions = calculateColumnPositions(items);
-        // Filter worktrees based on search query
-        const filteredWorktrees = filterWorktreesByQuery(items.map(item => item.worktree), searchQuery);
-        const filteredWorktreeSet = new Set(filteredWorktrees);
-        const filteredItems = items.filter(item => filteredWorktreeSet.has(item.worktree));
+        // Filter session items based on search query, matching the name shown in
+        // the menu (branch name, " (main)", and session name) plus the path.
+        const filteredItems = filterSessionItemsByQuery(items, searchQuery);
         // Build menu items with proper alignment
         const menuItems = filteredItems.map((item, index) => {
             const baseLabel = assembleSessionLabel(item, columnPositions);

package/dist/utils/filterByQuery.d.ts

@@ -1,5 +1,16 @@
 import { Worktree } from '../types/index.js';
+import { SessionItem } from './worktreeUtils.js';
 /**
  * Filter worktrees by matching search query against branch name and path.
  */
 export declare function filterWorktreesByQuery(worktrees: Worktree[], query: string): Worktree[];
+/**
+ * Filter session items by matching the search query against the name shown in
+ * the menu (branch name, " (main)" indicator, and session name) and the
+ * worktree path. Status icons and git status columns are not matched.
+ *
+ * Filtering happens per session item (not per worktree) so that a query can
+ * match an individual session name within a worktree that has multiple
+ * sessions.
+ */
+export declare function filterSessionItemsByQuery(items: SessionItem[], query: string): SessionItem[];

package/dist/utils/filterByQuery.js

@@ -11,3 +11,19 @@ export function filterWorktreesByQuery(worktrees, query) {
             worktree.path.toLowerCase().includes(searchLower));
     });
 }
+/**
+ * Filter session items by matching the search query against the name shown in
+ * the menu (branch name, " (main)" indicator, and session name) and the
+ * worktree path. Status icons and git status columns are not matched.
+ *
+ * Filtering happens per session item (not per worktree) so that a query can
+ * match an individual session name within a worktree that has multiple
+ * sessions.
+ */
+export function filterSessionItemsByQuery(items, query) {
+    if (!query)
+        return items;
+    const searchLower = query.toLowerCase();
+    return items.filter(item => item.searchableName.toLowerCase().includes(searchLower) ||
+        item.worktree.path.toLowerCase().includes(searchLower));
+}

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

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

package/dist/utils/filterByQuery.test.js

@@ -0,0 +1,81 @@
+import { describe, it, expect } from 'vitest';
+import { filterWorktreesByQuery, filterSessionItemsByQuery, } from './filterByQuery.js';
+const makeItem = (searchableName, path) => ({
+    worktree: {
+        path,
+        isMainWorktree: false,
+        hasSession: false,
+    },
+    baseLabel: searchableName,
+    searchableName,
+    fileChanges: '',
+    aheadBehind: '',
+    parentBranch: '',
+    lastCommitDate: '',
+    lengths: {
+        base: 0,
+        fileChanges: 0,
+        aheadBehind: 0,
+        parentBranch: 0,
+        lastCommitDate: 0,
+    },
+});
+describe('filterWorktreesByQuery', () => {
+    const worktrees = [
+        {
+            path: '/repo/feature-a',
+            branch: 'feature/a',
+            isMainWorktree: false,
+            hasSession: false,
+        },
+        {
+            path: '/repo/main',
+            branch: 'main',
+            isMainWorktree: true,
+            hasSession: false,
+        },
+    ];
+    it('returns all worktrees when query is empty', () => {
+        expect(filterWorktreesByQuery(worktrees, '')).toEqual(worktrees);
+    });
+    it('matches branch name case-insensitively', () => {
+        const result = filterWorktreesByQuery(worktrees, 'FEATURE');
+        expect(result).toHaveLength(1);
+        expect(result[0]?.branch).toBe('feature/a');
+    });
+    it('matches path', () => {
+        const result = filterWorktreesByQuery(worktrees, '/repo/main');
+        expect(result).toHaveLength(1);
+        expect(result[0]?.path).toBe('/repo/main');
+    });
+});
+describe('filterSessionItemsByQuery', () => {
+    const items = [
+        makeItem('feature/a', '/repo/feature-a'),
+        makeItem('main (main)', '/repo/main'),
+        makeItem('feature/b: my-session', '/repo/feature-b'),
+        makeItem('feature/b: other', '/repo/feature-b'),
+    ];
+    it('returns all items when query is empty', () => {
+        expect(filterSessionItemsByQuery(items, '')).toEqual(items);
+    });
+    it('matches the session name within a worktree', () => {
+        const result = filterSessionItemsByQuery(items, 'my-session');
+        expect(result).toHaveLength(1);
+        expect(result[0]?.searchableName).toBe('feature/b: my-session');
+    });
+    it('matches the (main) indicator', () => {
+        const result = filterSessionItemsByQuery(items, '(main)');
+        expect(result).toHaveLength(1);
+        expect(result[0]?.searchableName).toBe('main (main)');
+    });
+    it('matches branch name case-insensitively', () => {
+        const result = filterSessionItemsByQuery(items, 'FEATURE/A');
+        expect(result).toHaveLength(1);
+        expect(result[0]?.searchableName).toBe('feature/a');
+    });
+    it('matches path', () => {
+        const result = filterSessionItemsByQuery(items, '/repo/feature-b');
+        expect(result).toHaveLength(2);
+    });
+});

package/dist/utils/worktreeUtils.d.ts

@@ -6,6 +6,7 @@ export interface SessionItem {
     worktree: Worktree;
     session?: Session;
     baseLabel: string;
+    searchableName: string;
     fileChanges: string;
     aheadBehind: string;
     parentBranch: string;
@@ -24,7 +25,31 @@ export interface SessionItem {
  */
 export declare function formatRelativeDate(date: Date): string;
 export declare function truncateString(str: string, maxLength: number): string;
+/**
+ * Sanitize a branch name into the form used for a worktree directory name:
+ * slashes become dashes, characters outside [a-zA-Z0-9-_.] are stripped,
+ * leading/trailing dashes are removed, and the result is lowercased.
+ *
+ * This is the single source of truth for that mapping. It is reused both to
+ * generate worktree directories (see {@link generateWorktreeDirectory}) and to
+ * decide whether an existing directory name already conveys the branch name
+ * (see {@link formatWorktreeDirectorySuffix}), so a directory generated from a
+ * branch is reliably recognized as a match.
+ */
+export declare function sanitizeNameForDirectory(value: string): string;
 export declare function generateWorktreeDirectory(projectPath: string, branchName: string, pattern?: string): string;
+/**
+ * Returns the worktree directory basename to show alongside the branch name,
+ * or an empty string when it would be redundant (main worktree, detached,
+ * or the directory name matches the branch).
+ *
+ * The visible suffix is truncated; the raw basename is also returned so
+ * callers that want to make it searchable can include it untruncated.
+ */
+export declare function formatWorktreeDirectorySuffix(wt: Worktree, fullBranchName: string): {
+    displaySuffix: string;
+    rawName: string;
+};
 export declare function extractBranchParts(branchName: string): {
     prefix?: string;
     name: string;

package/dist/utils/worktreeUtils.js

@@ -5,6 +5,7 @@ import { getStatusDisplay } from '../constants/statusIcons.js';
 import { formatGitFileChanges, formatGitAheadBehind, formatParentBranch, } from './gitStatus.js';
 // Constants
 const MAX_BRANCH_NAME_LENGTH = 70; // Maximum characters for branch name display
+const MAX_WORKTREE_DIR_NAME_LENGTH = 30; // Maximum characters for the worktree directory name suffix
 const MIN_COLUMN_PADDING = 2; // Minimum spaces between columns
 /**
  * Format a date as a relative time string (e.g., "2h ago", "3d ago").
@@ -64,6 +65,24 @@ function getGitRepositoryName(projectPath) {
         return path.basename(projectPath);
     }
 }
+/**
+ * Sanitize a branch name into the form used for a worktree directory name:
+ * slashes become dashes, characters outside [a-zA-Z0-9-_.] are stripped,
+ * leading/trailing dashes are removed, and the result is lowercased.
+ *
+ * This is the single source of truth for that mapping. It is reused both to
+ * generate worktree directories (see {@link generateWorktreeDirectory}) and to
+ * decide whether an existing directory name already conveys the branch name
+ * (see {@link formatWorktreeDirectorySuffix}), so a directory generated from a
+ * branch is reliably recognized as a match.
+ */
+export function sanitizeNameForDirectory(value) {
+    return value
+        .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
+}
 export function generateWorktreeDirectory(projectPath, branchName, pattern) {
     // Default pattern if not specified
     const defaultPattern = '../{branch}';
@@ -74,12 +93,7 @@ export function generateWorktreeDirectory(projectPath, branchName, pattern) {
         switch (name) {
             case 'branch':
             case 'branch-name':
-                // Sanitize branch name for filesystem
-                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
+                sanitizedBranch ??= sanitizeNameForDirectory(branchName);
                 return sanitizedBranch;
             case 'project':
                 projectName ??= getGitRepositoryName(projectPath);
@@ -91,6 +105,40 @@ export function generateWorktreeDirectory(projectPath, branchName, pattern) {
     // Ensure the path is relative to the repository root
     return path.normalize(directory);
 }
+/**
+ * Returns the worktree directory basename to show alongside the branch name,
+ * or an empty string when it would be redundant (main worktree, detached,
+ * or the directory name matches the branch).
+ *
+ * The visible suffix is truncated; the raw basename is also returned so
+ * callers that want to make it searchable can include it untruncated.
+ */
+export function formatWorktreeDirectorySuffix(wt, fullBranchName) {
+    if (wt.isMainWorktree)
+        return { displaySuffix: '', rawName: '' };
+    if (!wt.branch)
+        return { displaySuffix: '', rawName: '' };
+    if (!wt.path)
+        return { displaySuffix: '', rawName: '' };
+    const dirName = path.basename(wt.path);
+    if (!dirName)
+        return { displaySuffix: '', rawName: '' };
+    const normalizedDir = sanitizeNameForDirectory(dirName);
+    if (!normalizedDir)
+        return { displaySuffix: '', rawName: '' };
+    const normalizedBranch = sanitizeNameForDirectory(fullBranchName);
+    if (normalizedDir === normalizedBranch) {
+        return { displaySuffix: '', rawName: '' };
+    }
+    // Also suppress when the directory matches just the tail segment of the
+    // branch (e.g. branch "feature/foo" vs directory "foo").
+    const tail = extractBranchParts(fullBranchName).name;
+    if (tail && sanitizeNameForDirectory(tail) === normalizedDir) {
+        return { displaySuffix: '', rawName: '' };
+    }
+    const visible = truncateString(dirName, MAX_WORKTREE_DIR_NAME_LENGTH);
+    return { displaySuffix: ` @ ${visible}`, rawName: dirName };
+}
 export function extractBranchParts(branchName) {
     const parts = branchName.split('/');
     if (parts.length > 1) {
@@ -165,7 +213,12 @@ function buildSessionItem(wt, session, sessionSuffix) {
         : 'detached';
     const branchName = truncateString(fullBranchName, MAX_BRANCH_NAME_LENGTH);
     const isMain = wt.isMainWorktree ? ' (main)' : '';
-    const baseLabel = `${branchName}${isMain}${sessionSuffix}${status}`;
+    const { displaySuffix: dirSuffix, rawName: rawDirName } = formatWorktreeDirectorySuffix(wt, fullBranchName);
+    const baseLabel = `${branchName}${dirSuffix}${isMain}${sessionSuffix}${status}`;
+    // Use the full (untruncated) branch name so search still matches the tail
+    // of long branch names; status icons are excluded so they don't match.
+    const rawDirForSearch = rawDirName ? ` @ ${rawDirName}` : '';
+    const searchableName = `${fullBranchName}${rawDirForSearch}${isMain}${sessionSuffix}`;
     const { fileChanges, aheadBehind, parentBranch, error } = gitStatusColumns(wt, fullBranchName);
     const lastCommitDate = wt.lastCommitDate
         ? `\x1b[90m${formatRelativeDate(wt.lastCommitDate)}\x1b[0m`
@@ -174,6 +227,7 @@ function buildSessionItem(wt, session, sessionSuffix) {
         worktree: wt,
         session,
         baseLabel,
+        searchableName,
         fileChanges,
         aheadBehind,
         parentBranch,

package/dist/utils/worktreeUtils.test.js

@@ -113,8 +113,10 @@ describe('truncateString', () => {
     });
 });
 describe('prepareSessionItems', () => {
+    // The directory basename here matches the sanitized branch tail so the
+    // worktree-directory suffix is suppressed in the basic baseLabel tests.
     const mockWorktree = {
-        path: '/path/to/worktree',
+        path: '/path/to/test-branch',
         branch: 'feature/test-branch',
         isMainWorktree: false,
         hasSession: false,
@@ -122,7 +124,7 @@ describe('prepareSessionItems', () => {
     // Simplified mock
     const mockSession = {
         id: 'test-session',
-        worktreePath: '/path/to/worktree',
+        worktreePath: '/path/to/test-branch',
         sessionNumber: 1,
         command: 'claude',
         fallbackArgs: undefined,
@@ -167,12 +169,115 @@ describe('prepareSessionItems', () => {
         const items = prepareSessionItems([longBranch], []);
         expect(items[0]?.baseLabel.length).toBeLessThanOrEqual(80); // 70 + status + default
     });
+    describe('worktree directory suffix', () => {
+        it('shows the directory name when it differs from the branch', () => {
+            const wt = {
+                path: '/repos/myproj/worktrees/login-api',
+                branch: 'feature/login',
+                isMainWorktree: false,
+                hasSession: false,
+            };
+            const items = prepareSessionItems([wt], []);
+            expect(items[0]?.baseLabel).toBe('feature/login @ login-api');
+        });
+        it('hides the directory name when the directory equals the branch tail', () => {
+            const wt = {
+                path: '/repos/myproj/worktrees/foo',
+                branch: 'feature/foo',
+                isMainWorktree: false,
+                hasSession: false,
+            };
+            const items = prepareSessionItems([wt], []);
+            expect(items[0]?.baseLabel).toBe('feature/foo');
+        });
+        it('hides the directory name when it matches the sanitized full branch', () => {
+            const wt = {
+                path: '/repos/myproj/worktrees/feature-foo',
+                branch: 'feature/foo',
+                isMainWorktree: false,
+                hasSession: false,
+            };
+            const items = prepareSessionItems([wt], []);
+            expect(items[0]?.baseLabel).toBe('feature/foo');
+        });
+        it('hides the directory name for the main worktree', () => {
+            const wt = {
+                path: '/repos/myproj',
+                branch: 'main',
+                isMainWorktree: true,
+                hasSession: false,
+            };
+            const items = prepareSessionItems([wt], []);
+            expect(items[0]?.baseLabel).toBe('main (main)');
+        });
+        it('truncates long directory names in the displayed label', () => {
+            const longDir = '/repos/myproj/worktrees/this-is-a-very-long-directory-name-that-should-be-truncated';
+            const wt = {
+                path: longDir,
+                branch: 'feature/short',
+                isMainWorktree: false,
+                hasSession: false,
+            };
+            const items = prepareSessionItems([wt], []);
+            // "feature/short @ " (16 chars) + up to MAX_WORKTREE_DIR_NAME_LENGTH (30)
+            const after = items[0]?.baseLabel.split(' @ ')[1] ?? '';
+            expect(after.length).toBeLessThanOrEqual(30);
+            expect(after.endsWith('...')).toBe(true);
+        });
+        it('keeps the untruncated directory basename in searchableName', () => {
+            const longDir = '/repos/myproj/worktrees/this-is-a-very-long-directory-name-that-should-be-truncated';
+            const wt = {
+                path: longDir,
+                branch: 'feature/short',
+                isMainWorktree: false,
+                hasSession: false,
+            };
+            const items = prepareSessionItems([wt], []);
+            expect(items[0]?.searchableName).toContain('this-is-a-very-long-directory-name-that-should-be-truncated');
+        });
+        it('places the directory suffix before session and status markers', () => {
+            const wt = {
+                path: '/repos/myproj/worktrees/foo-api',
+                branch: 'feature/foo',
+                isMainWorktree: false,
+                hasSession: false,
+            };
+            const items = prepareSessionItems([wt], [
+                {
+                    ...mockSession,
+                    worktreePath: '/repos/myproj/worktrees/foo-api',
+                    sessionName: 'lab',
+                },
+            ]);
+            // Order must be: branch, dir suffix, (no main), session suffix, status.
+            expect(items[0]?.baseLabel).toMatch(/^feature\/foo @ foo-api: lab \[.*Idle.*\]$/);
+        });
+        it('does not break column alignment when a dir suffix is appended', () => {
+            const items = prepareSessionItems([
+                {
+                    path: '/repos/myproj/worktrees/foo-api',
+                    branch: 'feature/foo',
+                    isMainWorktree: false,
+                    hasSession: false,
+                },
+                {
+                    path: '/repos/myproj',
+                    branch: 'main',
+                    isMainWorktree: true,
+                    hasSession: false,
+                },
+            ], []);
+            expect(items[0]?.lengths.base).toBe(items[0]?.baseLabel.length);
+            expect(items[1]?.lengths.base).toBe(items[1]?.baseLabel.length);
+        });
+    });
 });
 describe('column alignment', () => {
     const mockItems = [
         {
             worktree: {},
             baseLabel: 'feature/test-branch',
+            searchableName: 'feature/test-branch',
             fileChanges: '\x1b[32m+10\x1b[0m \x1b[31m-5\x1b[0m',
             aheadBehind: '\x1b[33m↑2 ↓3\x1b[0m',
             parentBranch: '',
@@ -188,6 +293,7 @@ describe('column alignment', () => {
         {
             worktree: {},
             baseLabel: 'main',
+            searchableName: 'main',
             fileChanges: '\x1b[32m+2\x1b[0m \x1b[31m-1\x1b[0m',
             aheadBehind: '\x1b[33m↑1\x1b[0m',
             parentBranch: '',

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "4.1.20",
+	"version": "4.1.22",
 	"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": "4.1.20",
-		"@kodaikabasawa/ccmanager-darwin-x64": "4.1.20",
-		"@kodaikabasawa/ccmanager-linux-arm64": "4.1.20",
-		"@kodaikabasawa/ccmanager-linux-x64": "4.1.20",
-		"@kodaikabasawa/ccmanager-win32-x64": "4.1.20"
+		"@kodaikabasawa/ccmanager-darwin-arm64": "4.1.22",
+		"@kodaikabasawa/ccmanager-darwin-x64": "4.1.22",
+		"@kodaikabasawa/ccmanager-linux-arm64": "4.1.22",
+		"@kodaikabasawa/ccmanager-linux-x64": "4.1.22",
+		"@kodaikabasawa/ccmanager-win32-x64": "4.1.22"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",