ccmanager 0.1.14 → 0.2.0

package/dist/cli.js

@@ -3,6 +3,7 @@ import React from 'react';
 import { render } from 'ink';
 import meow from 'meow';
 import App from './components/App.js';
+import { worktreeConfigManager } from './services/worktreeConfigManager.js';
 meow(`
 	Usage
 	  $ ccmanager
@@ -21,4 +22,6 @@ if (!process.stdin.isTTY || !process.stdout.isTTY) {
     console.error('Error: ccmanager must be run in an interactive terminal (TTY)');
     process.exit(1);
 }
+// Initialize worktree config manager
+worktreeConfigManager.initialize();
 render(React.createElement(App, null));

package/dist/components/Configuration.js

@@ -1,31 +1,32 @@
 import React, { useState } from 'react';
-import { Box, Text } from 'ink';
+import { Box, Text, useInput } from 'ink';
 import SelectInput from 'ink-select-input';
 import ConfigureShortcuts from './ConfigureShortcuts.js';
 import ConfigureHooks from './ConfigureHooks.js';
 import ConfigureWorktree from './ConfigureWorktree.js';
 import ConfigureCommand from './ConfigureCommand.js';
+import { shortcutManager } from '../services/shortcutManager.js';
 const Configuration = ({ onComplete }) => {
     const [view, setView] = useState('menu');
     const menuItems = [
         {
-            label: '⌨  Configure Shortcuts',
+            label: 'S ⌨  Configure Shortcuts',
             value: 'shortcuts',
         },
         {
-            label: '🔧  Configure Status Hooks',
+            label: 'H 🔧  Configure Status Hooks',
             value: 'hooks',
         },
         {
-            label: '📁  Configure Worktree Settings',
+            label: 'W 📁  Configure Worktree Settings',
             value: 'worktree',
         },
         {
-            label: '🚀  Configure Command',
+            label: 'C 🚀  Configure Command',
             value: 'command',
         },
         {
-            label: '← Back to Main Menu',
+            label: 'B ← Back to Main Menu',
             value: 'back',
         },
     ];
@@ -49,6 +50,33 @@ const Configuration = ({ onComplete }) => {
     const handleSubMenuComplete = () => {
         setView('menu');
     };
+    // Handle hotkeys (only when in menu view)
+    useInput((input, key) => {
+        if (view !== 'menu')
+            return; // Only handle hotkeys in menu view
+        const keyPressed = input.toLowerCase();
+        switch (keyPressed) {
+            case 's':
+                setView('shortcuts');
+                break;
+            case 'h':
+                setView('hooks');
+                break;
+            case 'w':
+                setView('worktree');
+                break;
+            case 'c':
+                setView('command');
+                break;
+            case 'b':
+                onComplete();
+                break;
+        }
+        // Handle escape key
+        if (shortcutManager.matchesShortcut('cancel', input, key)) {
+            onComplete();
+        }
+    });
     if (view === 'shortcuts') {
         return React.createElement(ConfigureShortcuts, { onComplete: handleSubMenuComplete });
     }

package/dist/components/Menu.js

@@ -1,17 +1,22 @@
 import React, { useState, useEffect } from 'react';
-import { Box, Text } from 'ink';
+import { Box, Text, useInput } from 'ink';
 import SelectInput from 'ink-select-input';
 import { WorktreeService } from '../services/worktreeService.js';
-import { STATUS_ICONS, STATUS_LABELS, MENU_ICONS, getStatusDisplay, } from '../constants/statusIcons.js';
+import { STATUS_ICONS, STATUS_LABELS, MENU_ICONS, } from '../constants/statusIcons.js';
+import { useGitStatus } from '../hooks/useGitStatus.js';
+import { prepareWorktreeItems, calculateColumnPositions, assembleWorktreeLabel, } from '../utils/worktreeUtils.js';
 const Menu = ({ sessionManager, onSelectWorktree }) => {
-    const [worktrees, setWorktrees] = useState([]);
+    const [baseWorktrees, setBaseWorktrees] = useState([]);
+    const [defaultBranch, setDefaultBranch] = useState(null);
+    const worktrees = useGitStatus(baseWorktrees, defaultBranch);
     const [sessions, setSessions] = useState([]);
     const [items, setItems] = useState([]);
     useEffect(() => {
         // Load worktrees
         const worktreeService = new WorktreeService();
         const loadedWorktrees = worktreeService.getWorktrees();
-        setWorktrees(loadedWorktrees);
+        setBaseWorktrees(loadedWorktrees);
+        setDefaultBranch(worktreeService.getDefaultBranch());
         // Update sessions
         const updateSessions = () => {
             const allSessions = sessionManager.getAllSessions();
@@ -34,21 +39,18 @@ const Menu = ({ sessionManager, onSelectWorktree }) => {
         };
     }, [sessionManager]);
     useEffect(() => {
-        // Build menu items
-        const menuItems = worktrees.map(wt => {
-            const session = sessions.find(s => s.worktreePath === wt.path);
-            let status = '';
-            if (session) {
-                status = ` [${getStatusDisplay(session.state)}]`;
-            }
-            const branchName = wt.branch
-                ? wt.branch.replace('refs/heads/', '')
-                : 'detached';
-            const isMain = wt.isMainWorktree ? ' (main)' : '';
+        // Prepare worktree items and calculate layout
+        const items = prepareWorktreeItems(worktrees, sessions);
+        const columnPositions = calculateColumnPositions(items);
+        // Build menu items with proper alignment
+        const menuItems = items.map((item, index) => {
+            const label = assembleWorktreeLabel(item, columnPositions);
+            // Only show numbers for first 10 worktrees (0-9)
+            const numberPrefix = index < 10 ? `${index} ❯ ` : '❯ ';
             return {
-                label: `${branchName}${isMain}${status}`,
-                value: wt.path,
-                worktree: wt,
+                label: numberPrefix + label,
+                value: item.worktree.path,
+                worktree: item.worktree,
             };
         });
         // Add menu options
@@ -57,27 +59,87 @@ const Menu = ({ sessionManager, onSelectWorktree }) => {
             value: 'separator',
         });
         menuItems.push({
-            label: `${MENU_ICONS.NEW_WORKTREE} New Worktree`,
+            label: `N ${MENU_ICONS.NEW_WORKTREE} New Worktree`,
             value: 'new-worktree',
         });
         menuItems.push({
-            label: `${MENU_ICONS.MERGE_WORKTREE} Merge Worktree`,
+            label: `M ${MENU_ICONS.MERGE_WORKTREE} Merge Worktree`,
             value: 'merge-worktree',
         });
         menuItems.push({
-            label: `${MENU_ICONS.DELETE_WORKTREE} Delete Worktree`,
+            label: `D ${MENU_ICONS.DELETE_WORKTREE} Delete Worktree`,
             value: 'delete-worktree',
         });
         menuItems.push({
-            label: `${MENU_ICONS.CONFIGURE_SHORTCUTS} Configuration`,
+            label: `C ${MENU_ICONS.CONFIGURE_SHORTCUTS} Configuration`,
             value: 'configuration',
         });
         menuItems.push({
-            label: `${MENU_ICONS.EXIT} Exit`,
+            label: `Q ${MENU_ICONS.EXIT} Exit`,
             value: 'exit',
         });
         setItems(menuItems);
-    }, [worktrees, sessions]);
+    }, [worktrees, sessions, defaultBranch]);
+    // Handle hotkeys
+    useInput((input, _key) => {
+        const keyPressed = input.toLowerCase();
+        // Handle number keys 0-9 for worktree selection (first 10 only)
+        if (/^[0-9]$/.test(keyPressed)) {
+            const index = parseInt(keyPressed);
+            if (index < Math.min(10, worktrees.length) && worktrees[index]) {
+                onSelectWorktree(worktrees[index]);
+            }
+            return;
+        }
+        switch (keyPressed) {
+            case 'n':
+                // Trigger new worktree action
+                onSelectWorktree({
+                    path: '',
+                    branch: '',
+                    isMainWorktree: false,
+                    hasSession: false,
+                });
+                break;
+            case 'm':
+                // Trigger merge worktree action
+                onSelectWorktree({
+                    path: 'MERGE_WORKTREE',
+                    branch: '',
+                    isMainWorktree: false,
+                    hasSession: false,
+                });
+                break;
+            case 'd':
+                // Trigger delete worktree action
+                onSelectWorktree({
+                    path: 'DELETE_WORKTREE',
+                    branch: '',
+                    isMainWorktree: false,
+                    hasSession: false,
+                });
+                break;
+            case 'c':
+                // Trigger configuration action
+                onSelectWorktree({
+                    path: 'CONFIGURATION',
+                    branch: '',
+                    isMainWorktree: false,
+                    hasSession: false,
+                });
+                break;
+            case 'q':
+            case 'x':
+                // Trigger exit action
+                onSelectWorktree({
+                    path: 'EXIT_APPLICATION',
+                    branch: '',
+                    isMainWorktree: false,
+                    hasSession: false,
+                });
+                break;
+        }
+    });
     const handleSelect = (item) => {
         if (item.value === 'separator') {
             // Do nothing for separator
@@ -151,6 +213,6 @@ const Menu = ({ sessionManager, onSelectWorktree }) => {
                 STATUS_ICONS.IDLE,
                 ' ',
                 STATUS_LABELS.IDLE),
-            React.createElement(Text, { dimColor: true }, "Controls: \u2191\u2193 Navigate Enter Select"))));
+            React.createElement(Text, { dimColor: true }, "Controls: \u2191\u2193 Navigate Enter Select | Hotkeys: 0-9 Quick Select (first 10) N-New M-Merge D-Delete C-Config Q-Quit"))));
 };
 export default Menu;

package/dist/hooks/useGitStatus.d.ts

@@ -0,0 +1,2 @@
+import { Worktree } from '../types/index.js';
+export declare function useGitStatus(worktrees: Worktree[], defaultBranch: string | null, updateInterval?: number): Worktree[];

package/dist/hooks/useGitStatus.js

@@ -0,0 +1,52 @@
+import { useEffect, useState } from 'react';
+import { getGitStatusLimited } from '../utils/gitStatus.js';
+export function useGitStatus(worktrees, defaultBranch, updateInterval = 5000) {
+    const [worktreesWithStatus, setWorktreesWithStatus] = useState(worktrees);
+    useEffect(() => {
+        if (!defaultBranch) {
+            return;
+        }
+        const timeouts = new Map();
+        const activeRequests = new Map();
+        let isCleanedUp = false;
+        const fetchStatus = async (worktree, abortController) => {
+            try {
+                const result = await getGitStatusLimited(worktree.path, abortController.signal);
+                if (result.data || result.error) {
+                    setWorktreesWithStatus(prev => prev.map(wt => wt.path === worktree.path
+                        ? { ...wt, gitStatus: result.data, gitStatusError: result.error }
+                        : wt));
+                }
+            }
+            catch {
+                // Ignore errors - the fetch failed or was aborted
+            }
+        };
+        const scheduleUpdate = (worktree) => {
+            const abortController = new AbortController();
+            activeRequests.set(worktree.path, abortController);
+            fetchStatus(worktree, abortController).finally(() => {
+                const isActive = () => !isCleanedUp && !abortController.signal.aborted;
+                if (isActive()) {
+                    const timeout = setTimeout(() => {
+                        if (isActive()) {
+                            scheduleUpdate(worktree);
+                        }
+                    }, updateInterval);
+                    timeouts.set(worktree.path, timeout);
+                }
+            });
+        };
+        setWorktreesWithStatus(worktrees);
+        // Start fetching for each worktree
+        worktrees.forEach(worktree => {
+            scheduleUpdate(worktree);
+        });
+        return () => {
+            isCleanedUp = true;
+            timeouts.forEach(timeout => clearTimeout(timeout));
+            activeRequests.forEach(controller => controller.abort());
+        };
+    }, [worktrees, defaultBranch, updateInterval]);
+    return worktreesWithStatus;
+}

package/dist/hooks/useGitStatus.test.d.ts

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

package/dist/hooks/useGitStatus.test.js

@@ -0,0 +1,186 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import React from 'react';
+import { render, cleanup } from 'ink-testing-library';
+import { Text } from 'ink';
+import { useGitStatus } from './useGitStatus.js';
+import { getGitStatusLimited } from '../utils/gitStatus.js';
+// Mock the gitStatus module
+vi.mock('../utils/gitStatus.js', () => ({
+    getGitStatusLimited: vi.fn(),
+}));
+describe('useGitStatus', () => {
+    const mockGetGitStatus = getGitStatusLimited;
+    const createWorktree = (path) => ({
+        path,
+        branch: 'main',
+        isMainWorktree: false,
+        hasSession: false,
+    });
+    const createGitStatus = (added = 1, deleted = 0) => ({
+        filesAdded: added,
+        filesDeleted: deleted,
+        aheadCount: 0,
+        behindCount: 0,
+        parentBranch: 'main',
+    });
+    beforeEach(() => {
+        vi.useFakeTimers();
+        mockGetGitStatus.mockClear();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+        cleanup();
+    });
+    // Main behavioral test
+    it('should fetch and update git status for worktrees', async () => {
+        const worktrees = [createWorktree('/path1'), createWorktree('/path2')];
+        const gitStatus1 = createGitStatus(5, 3);
+        const gitStatus2 = createGitStatus(2, 1);
+        let hookResult = [];
+        mockGetGitStatus.mockImplementation(async (path) => {
+            if (path === '/path1') {
+                return { success: true, data: gitStatus1 };
+            }
+            return { success: true, data: gitStatus2 };
+        });
+        const TestComponent = () => {
+            hookResult = useGitStatus(worktrees, 'main', 100);
+            return React.createElement(Text, null, 'test');
+        };
+        render(React.createElement(TestComponent));
+        // Should return worktrees immediately
+        expect(hookResult).toEqual(worktrees);
+        // Wait for status updates
+        await vi.waitFor(() => {
+            expect(hookResult[0]?.gitStatus).toBeDefined();
+            expect(hookResult[1]?.gitStatus).toBeDefined();
+        });
+        // Should have correct status for each worktree
+        expect(hookResult[0]?.gitStatus).toEqual(gitStatus1);
+        expect(hookResult[1]?.gitStatus).toEqual(gitStatus2);
+    });
+    it('should handle empty worktree array', () => {
+        let hookResult = [];
+        const TestComponent = () => {
+            hookResult = useGitStatus([], 'main');
+            return React.createElement(Text, null, 'test');
+        };
+        render(React.createElement(TestComponent));
+        expect(hookResult).toEqual([]);
+        expect(mockGetGitStatus).not.toHaveBeenCalled();
+    });
+    it('should not fetch when defaultBranch is null', async () => {
+        const worktrees = [createWorktree('/path1'), createWorktree('/path2')];
+        let hookResult = [];
+        const TestComponent = () => {
+            hookResult = useGitStatus(worktrees, null);
+            return React.createElement(Text, null, 'test');
+        };
+        render(React.createElement(TestComponent));
+        // Should return worktrees immediately without modification
+        expect(hookResult).toEqual(worktrees);
+        // Wait to ensure no fetches occur
+        await vi.advanceTimersByTimeAsync(1000);
+        expect(mockGetGitStatus).not.toHaveBeenCalled();
+    });
+    it('should continue polling after errors', async () => {
+        const worktrees = [createWorktree('/path1')];
+        mockGetGitStatus.mockResolvedValue({
+            success: false,
+            error: 'Git error',
+        });
+        const TestComponent = () => {
+            useGitStatus(worktrees, 'main', 100);
+            return React.createElement(Text, null, 'test');
+        };
+        render(React.createElement(TestComponent));
+        // Wait for initial fetch
+        await vi.waitFor(() => {
+            expect(mockGetGitStatus).toHaveBeenCalledTimes(1);
+        });
+        // Clear to track subsequent calls
+        mockGetGitStatus.mockClear();
+        // Advance time and verify polling continues despite errors
+        await vi.advanceTimersByTimeAsync(100);
+        expect(mockGetGitStatus).toHaveBeenCalledTimes(1);
+        await vi.advanceTimersByTimeAsync(100);
+        expect(mockGetGitStatus).toHaveBeenCalledTimes(2);
+        // All calls should have been made despite continuous errors
+        expect(mockGetGitStatus).toHaveBeenCalledWith('/path1', expect.any(AbortSignal));
+    });
+    it('should handle slow git operations that exceed update interval', async () => {
+        const worktrees = [createWorktree('/path1')];
+        let fetchCount = 0;
+        let resolveFetch = null;
+        mockGetGitStatus.mockImplementation(async () => {
+            fetchCount++;
+            // Create a promise that we can resolve manually
+            return new Promise(resolve => {
+                resolveFetch = resolve;
+            });
+        });
+        const TestComponent = () => {
+            useGitStatus(worktrees, 'main', 100);
+            return React.createElement(Text, null, 'test');
+        };
+        render(React.createElement(TestComponent));
+        // Wait for initial fetch to start
+        await vi.waitFor(() => {
+            expect(mockGetGitStatus).toHaveBeenCalledTimes(1);
+        });
+        // Advance time past the update interval while fetch is still pending
+        await vi.advanceTimersByTimeAsync(250);
+        // Should not have started a second fetch yet
+        expect(mockGetGitStatus).toHaveBeenCalledTimes(1);
+        // Complete the first fetch
+        resolveFetch({ success: true, data: createGitStatus(1, 0) });
+        // Wait for the promise to resolve
+        await vi.waitFor(() => {
+            expect(fetchCount).toBe(1);
+        });
+        // Now advance time by the update interval
+        await vi.advanceTimersByTimeAsync(100);
+        // Should have started the second fetch
+        await vi.waitFor(() => {
+            expect(mockGetGitStatus).toHaveBeenCalledTimes(2);
+        });
+    });
+    it('should properly cleanup resources when worktrees change', async () => {
+        let activeRequests = 0;
+        const abortedSignals = [];
+        mockGetGitStatus.mockImplementation(async (path, signal) => {
+            activeRequests++;
+            signal.addEventListener('abort', () => {
+                activeRequests--;
+                abortedSignals.push(signal);
+            });
+            // Simulate ongoing request
+            return new Promise(() => { });
+        });
+        const TestComponent = ({ worktrees }) => {
+            useGitStatus(worktrees, 'main', 100);
+            return React.createElement(Text, null, 'test');
+        };
+        // Start with 3 worktrees
+        const initialWorktrees = [
+            createWorktree('/path1'),
+            createWorktree('/path2'),
+            createWorktree('/path3'),
+        ];
+        const { rerender } = render(React.createElement(TestComponent, { worktrees: initialWorktrees }));
+        // Should have 3 active requests
+        await vi.waitFor(() => {
+            expect(activeRequests).toBe(3);
+        });
+        // Change to 2 different worktrees
+        const newWorktrees = [createWorktree('/path4'), createWorktree('/path5')];
+        rerender(React.createElement(TestComponent, { worktrees: newWorktrees }));
+        // Wait for cleanup and new requests
+        await vi.waitFor(() => {
+            expect(abortedSignals).toHaveLength(3);
+            expect(activeRequests).toBe(2);
+        });
+        // Verify all old signals were aborted
+        expect(abortedSignals.every(signal => signal.aborted)).toBe(true);
+    });
+});

package/dist/services/worktreeConfigManager.d.ts

@@ -0,0 +1,10 @@
+declare class WorktreeConfigManager {
+    private static instance;
+    private isExtensionAvailable;
+    private constructor();
+    static getInstance(): WorktreeConfigManager;
+    initialize(gitPath?: string): void;
+    isAvailable(): boolean;
+}
+export declare const worktreeConfigManager: WorktreeConfigManager;
+export {};

package/dist/services/worktreeConfigManager.js

@@ -0,0 +1,27 @@
+import { isWorktreeConfigEnabled } from '../utils/worktreeConfig.js';
+class WorktreeConfigManager {
+    constructor() {
+        Object.defineProperty(this, "isExtensionAvailable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    static getInstance() {
+        if (!WorktreeConfigManager.instance) {
+            WorktreeConfigManager.instance = new WorktreeConfigManager();
+        }
+        return WorktreeConfigManager.instance;
+    }
+    initialize(gitPath) {
+        this.isExtensionAvailable = isWorktreeConfigEnabled(gitPath);
+    }
+    isAvailable() {
+        if (this.isExtensionAvailable === null) {
+            throw new Error('WorktreeConfigManager not initialized');
+        }
+        return this.isExtensionAvailable;
+    }
+}
+export const worktreeConfigManager = WorktreeConfigManager.getInstance();

package/dist/services/worktreeService.js

@@ -1,6 +1,7 @@
 import { execSync } from 'child_process';
 import { existsSync } from 'fs';
 import path from 'path';
+import { setWorktreeParentBranch } from '../utils/worktreeConfig.js';
 export class WorktreeService {
     constructor(rootPath) {
         Object.defineProperty(this, "rootPath", {
@@ -201,6 +202,13 @@ export class WorktreeService {
                 cwd: this.gitRootPath, // Execute from git root to ensure proper resolution
                 encoding: 'utf8',
             });
+            // Store the parent branch in worktree config
+            try {
+                setWorktreeParentBranch(resolvedPath, baseBranch);
+            }
+            catch (error) {
+                console.error('Warning: Failed to set parent branch in worktree config:', error);
+            }
             return { success: true };
         }
         catch (error) {

package/dist/services/worktreeService.test.js

@@ -3,6 +3,14 @@ import { WorktreeService } from './worktreeService.js';
 import { execSync } from 'child_process';
 // Mock child_process module
 vi.mock('child_process');
+// Mock worktreeConfigManager
+vi.mock('./worktreeConfigManager.js', () => ({
+    worktreeConfigManager: {
+        initialize: vi.fn(),
+        isAvailable: vi.fn(() => true),
+        reset: vi.fn(),
+    },
+}));
 // Get the mocked function with proper typing
 const mockedExecSync = vi.mocked(execSync);
 describe('WorktreeService', () => {

package/dist/types/index.d.ts

@@ -1,5 +1,6 @@
 import { IPty } from 'node-pty';
 import type pkg from '@xterm/headless';
+import { GitStatus } from '../utils/gitStatus.js';
 export type Terminal = InstanceType<typeof pkg.Terminal>;
 export type SessionState = 'idle' | 'busy' | 'waiting_input';
 export interface Worktree {
@@ -7,6 +8,8 @@ export interface Worktree {
     branch?: string;
     isMainWorktree: boolean;
     hasSession: boolean;
+    gitStatus?: GitStatus;
+    gitStatusError?: string;
 }
 export interface Session {
     id: string;

package/dist/utils/concurrencyLimit.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Create a function that limits concurrent executions
+ */
+export declare function createConcurrencyLimited<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => Promise<TResult>, maxConcurrent: number): (...args: TArgs) => Promise<TResult>;

package/dist/utils/concurrencyLimit.js

@@ -0,0 +1,30 @@
+/**
+ * Create a function that limits concurrent executions
+ */
+export function createConcurrencyLimited(fn, maxConcurrent) {
+    if (maxConcurrent < 1) {
+        throw new RangeError('maxConcurrent must be at least 1');
+    }
+    let activeCount = 0;
+    const queue = [];
+    return async (...args) => {
+        // Wait for a slot if at capacity
+        if (activeCount >= maxConcurrent) {
+            await new Promise(resolve => {
+                queue.push(resolve);
+            });
+        }
+        activeCount++;
+        try {
+            return await fn(...args);
+        }
+        finally {
+            activeCount--;
+            // Release the next waiter in queue
+            const next = queue.shift();
+            if (next) {
+                next();
+            }
+        }
+    };
+}

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

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