ccmanager 0.0.1

package/README.md

@@ -0,0 +1,85 @@
+# CCManager - Claude Code Worktree Manager
+
+CCManager is a TUI application for managing multiple Claude Code sessions across Git worktrees.
+
+## Features
+
+- Run multiple Claude Code sessions in parallel across different Git worktrees
+- Switch between sessions seamlessly
+- Visual status indicators for session states (busy, waiting, idle)
+- Create, merge, and delete worktrees from within the app
+- **Configurable keyboard shortcuts**
+
+## Install
+
+```bash
+$ npm install
+$ npm run build
+$ npm start
+```
+
+## Usage
+
+```bash
+$ npx ccmanager
+```
+
+## Keyboard Shortcuts
+
+### Default Shortcuts
+
+- **Ctrl+E**: Return to menu from active session (by default)
+
+### Customizing Shortcuts
+
+You can customize keyboard shortcuts in two ways:
+
+1. **Through the UI**: Select "Configure Shortcuts" from the main menu
+2. **Configuration file**: Edit `~/.config/ccmanager/shortcuts.json`
+
+Example configuration:
+```json
+{
+  "returnToMenu": {
+    "ctrl": true,
+    "key": "r"
+  },
+  "exitApp": {
+    "ctrl": true,
+    "key": "x"
+  },
+  "cancel": {
+    "key": "escape"
+  }
+}
+```
+
+### Restrictions
+
+- Shortcuts must use a modifier key (Ctrl) except for special keys like Escape
+- The following key combinations are reserved and cannot be used:
+  - Ctrl+C
+  - Ctrl+D
+  - Ctrl+[ (equivalent to Escape)
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Run in development mode
+npm run dev
+
+# Build
+npm run build
+
+# Run tests
+npm test
+
+# Run linter
+npm run lint
+
+# Run type checker
+npm run typecheck
+```

package/dist/app.d.ts

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

package/dist/app.js

@@ -0,0 +1,57 @@
+import React, { useEffect, useState } from 'react';
+import { Box, Text, useInput, useApp, useStdout } from 'ink';
+import { spawn } from 'node-pty';
+const App = ({ onReturnToMenu }) => {
+    const { exit } = useApp();
+    const { stdout } = useStdout();
+    const [pty, setPty] = useState(null);
+    const [showMenu, setShowMenu] = useState(false);
+    useEffect(() => {
+        const ptyProcess = spawn('claude', [], {
+            name: 'xterm-color',
+            cols: process.stdout.columns || 80,
+            rows: process.stdout.rows || 24,
+            cwd: process.cwd(),
+            env: process.env,
+        });
+        ptyProcess.onData((data) => {
+            if (stdout) {
+                stdout.write(data);
+            }
+        });
+        ptyProcess.onExit(() => {
+            exit();
+        });
+        setPty(ptyProcess);
+        if (stdout) {
+            stdout.on('resize', () => {
+                ptyProcess.resize(process.stdout.columns || 80, process.stdout.rows || 24);
+            });
+        }
+        return () => {
+            ptyProcess.kill();
+        };
+    }, [exit, stdout]);
+    useInput((char, key) => {
+        if (!pty)
+            return;
+        if (key.ctrl && char === 'e') {
+            if (onReturnToMenu) {
+                onReturnToMenu();
+            }
+            else {
+                setShowMenu(true);
+            }
+            return;
+        }
+        // if (char) {
+        // 	pty.write(char);
+        // }
+    });
+    if (showMenu) {
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { color: "green" }, "Press Ctrl+E to return to menu")));
+    }
+    return null;
+};
+export default App;

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import React from 'react';
+import { render } from 'ink';
+import meow from 'meow';
+import App from './components/App.js';
+meow(`
+	Usage
+	  $ ccmanager
+
+	Options
+	  --help     Show help
+	  --version  Show version
+
+	Examples
+	  $ ccmanager
+`, {
+    importMeta: import.meta,
+});
+// Check if we're in a TTY environment
+if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    console.error('Error: ccmanager must be run in an interactive terminal (TTY)');
+    process.exit(1);
+}
+render(React.createElement(App, null));

package/dist/components/App.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const App: React.FC;
+export default App;

package/dist/components/App.js

@@ -0,0 +1,228 @@
+import React, { useState, useEffect } from 'react';
+import { useApp, Box, Text } from 'ink';
+import Menu from './Menu.js';
+import Session from './Session.js';
+import NewWorktree from './NewWorktree.js';
+import DeleteWorktree from './DeleteWorktree.js';
+import MergeWorktree from './MergeWorktree.js';
+import ConfigureShortcuts from './ConfigureShortcuts.js';
+import { SessionManager } from '../services/sessionManager.js';
+import { WorktreeService } from '../services/worktreeService.js';
+import { shortcutManager } from '../services/shortcutManager.js';
+const App = () => {
+    const { exit } = useApp();
+    const [view, setView] = useState('menu');
+    const [sessionManager] = useState(() => new SessionManager());
+    const [worktreeService] = useState(() => new WorktreeService());
+    const [activeSession, setActiveSession] = useState(null);
+    const [error, setError] = useState(null);
+    const [menuKey, setMenuKey] = useState(0); // Force menu refresh
+    useEffect(() => {
+        // Listen for session exits to return to menu automatically
+        const handleSessionExit = (session) => {
+            // If the exited session is the active one, return to menu
+            setActiveSession(current => {
+                if (current && session.id === current.id) {
+                    // Session that exited is the active one, trigger return to menu
+                    setTimeout(() => {
+                        setActiveSession(null);
+                        setError(null);
+                        setView('menu');
+                        setMenuKey(prev => prev + 1);
+                        if (process.stdout.isTTY) {
+                            process.stdout.write('\x1B[2J\x1B[H');
+                        }
+                        process.stdin.resume();
+                        process.stdin.setEncoding('utf8');
+                    }, 0);
+                }
+                return current;
+            });
+        };
+        sessionManager.on('sessionExit', handleSessionExit);
+        // Cleanup on unmount
+        return () => {
+            sessionManager.off('sessionExit', handleSessionExit);
+            sessionManager.destroy();
+        };
+    }, [sessionManager]);
+    const handleSelectWorktree = (worktree) => {
+        // Check if this is the new worktree option
+        if (worktree.path === '') {
+            setView('new-worktree');
+            return;
+        }
+        // Check if this is the delete worktree option
+        if (worktree.path === 'DELETE_WORKTREE') {
+            setView('delete-worktree');
+            return;
+        }
+        // Check if this is the merge worktree option
+        if (worktree.path === 'MERGE_WORKTREE') {
+            setView('merge-worktree');
+            return;
+        }
+        // Check if this is the configure shortcuts option
+        if (worktree.path === 'CONFIGURE_SHORTCUTS') {
+            setView('configure-shortcuts');
+            return;
+        }
+        // Check if this is the exit application option
+        if (worktree.path === 'EXIT_APPLICATION') {
+            sessionManager.destroy();
+            exit();
+            return;
+        }
+        // Get or create session for this worktree
+        let session = sessionManager.getSession(worktree.path);
+        if (!session) {
+            session = sessionManager.createSession(worktree.path);
+        }
+        setActiveSession(session);
+        setView('session');
+    };
+    const handleReturnToMenu = () => {
+        setActiveSession(null);
+        setError(null);
+        // Add a small delay to ensure Session cleanup completes
+        setTimeout(() => {
+            setView('menu');
+            setMenuKey(prev => prev + 1); // Force menu refresh
+            // Clear the screen when returning to menu
+            if (process.stdout.isTTY) {
+                process.stdout.write('\x1B[2J\x1B[H');
+            }
+            // Ensure stdin is in a clean state for Ink components
+            if (process.stdin.isTTY) {
+                // Flush any pending input to prevent escape sequences from leaking
+                process.stdin.read();
+                process.stdin.setRawMode(false);
+                process.stdin.resume();
+                process.stdin.setEncoding('utf8');
+            }
+        }, 50); // Small delay to ensure proper cleanup
+    };
+    const handleCreateWorktree = async (path, branch) => {
+        setView('creating-worktree');
+        setError(null);
+        // Create the worktree
+        const result = worktreeService.createWorktree(path, branch);
+        if (result.success) {
+            // Success - return to menu
+            handleReturnToMenu();
+        }
+        else {
+            // Show error
+            setError(result.error || 'Failed to create worktree');
+            setView('new-worktree');
+        }
+    };
+    const handleCancelNewWorktree = () => {
+        handleReturnToMenu();
+    };
+    const handleDeleteWorktrees = async (worktreePaths) => {
+        setView('deleting-worktree');
+        setError(null);
+        // Delete the worktrees
+        let hasError = false;
+        for (const path of worktreePaths) {
+            const result = worktreeService.deleteWorktree(path);
+            if (!result.success) {
+                hasError = true;
+                setError(result.error || 'Failed to delete worktree');
+                break;
+            }
+        }
+        if (!hasError) {
+            // Success - return to menu
+            handleReturnToMenu();
+        }
+        else {
+            // Show error
+            setView('delete-worktree');
+        }
+    };
+    const handleCancelDeleteWorktree = () => {
+        handleReturnToMenu();
+    };
+    const handleMergeWorktree = async (sourceBranch, targetBranch, deleteAfterMerge, useRebase) => {
+        setView('merging-worktree');
+        setError(null);
+        // Perform the merge
+        const mergeResult = worktreeService.mergeWorktree(sourceBranch, targetBranch, useRebase);
+        if (mergeResult.success) {
+            // If user wants to delete the merged branch
+            if (deleteAfterMerge) {
+                const deleteResult = worktreeService.deleteWorktreeByBranch(sourceBranch);
+                if (!deleteResult.success) {
+                    setError(deleteResult.error || 'Failed to delete merged worktree');
+                    setView('merge-worktree');
+                    return;
+                }
+            }
+            // Success - return to menu
+            handleReturnToMenu();
+        }
+        else {
+            // Show error
+            setError(mergeResult.error || 'Failed to merge branches');
+            setView('merge-worktree');
+        }
+    };
+    const handleCancelMergeWorktree = () => {
+        handleReturnToMenu();
+    };
+    if (view === 'menu') {
+        return (React.createElement(Menu, { key: menuKey, sessionManager: sessionManager, onSelectWorktree: handleSelectWorktree }));
+    }
+    if (view === 'session' && activeSession) {
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Session, { key: activeSession.id, session: activeSession, sessionManager: sessionManager, onReturnToMenu: handleReturnToMenu }),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true },
+                    "Press ",
+                    shortcutManager.getShortcutDisplay('returnToMenu'),
+                    " to return to menu"))));
+    }
+    if (view === 'new-worktree') {
+        return (React.createElement(Box, { flexDirection: "column" },
+            error && (React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { color: "red" },
+                    "Error: ",
+                    error))),
+            React.createElement(NewWorktree, { onComplete: handleCreateWorktree, onCancel: handleCancelNewWorktree })));
+    }
+    if (view === 'creating-worktree') {
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { color: "green" }, "Creating worktree...")));
+    }
+    if (view === 'delete-worktree') {
+        return (React.createElement(Box, { flexDirection: "column" },
+            error && (React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { color: "red" },
+                    "Error: ",
+                    error))),
+            React.createElement(DeleteWorktree, { onComplete: handleDeleteWorktrees, onCancel: handleCancelDeleteWorktree })));
+    }
+    if (view === 'deleting-worktree') {
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { color: "red" }, "Deleting worktrees...")));
+    }
+    if (view === 'merge-worktree') {
+        return (React.createElement(Box, { flexDirection: "column" },
+            error && (React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { color: "red" },
+                    "Error: ",
+                    error))),
+            React.createElement(MergeWorktree, { onComplete: handleMergeWorktree, onCancel: handleCancelMergeWorktree })));
+    }
+    if (view === 'merging-worktree') {
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { color: "green" }, "Merging worktrees...")));
+    }
+    if (view === 'configure-shortcuts') {
+        return React.createElement(ConfigureShortcuts, { onComplete: handleReturnToMenu });
+    }
+    return null;
+};
+export default App;

package/dist/components/ConfigureShortcuts.d.ts

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

package/dist/components/ConfigureShortcuts.js

@@ -0,0 +1,139 @@
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import SelectInput from 'ink-select-input';
+import { shortcutManager } from '../services/shortcutManager.js';
+const ConfigureShortcuts = ({ onComplete, }) => {
+    const [step, setStep] = useState('menu');
+    const [shortcuts, setShortcuts] = useState(shortcutManager.getShortcuts());
+    const [editingShortcut, setEditingShortcut] = useState(null);
+    const [error, setError] = useState(null);
+    const getShortcutDisplayFromState = (key) => {
+        const shortcut = shortcuts[key];
+        if (!shortcut)
+            return 'Not set';
+        const parts = [];
+        if (shortcut.ctrl)
+            parts.push('Ctrl');
+        if (shortcut.alt)
+            parts.push('Alt');
+        if (shortcut.shift)
+            parts.push('Shift');
+        if (shortcut.key === 'escape') {
+            parts.push('Esc');
+        }
+        else if (shortcut.key) {
+            parts.push(shortcut.key.toUpperCase());
+        }
+        return parts.join('+');
+    };
+    const shortcutItems = [
+        {
+            label: `Return to Menu: ${getShortcutDisplayFromState('returnToMenu')}`,
+            value: 'returnToMenu',
+        },
+        {
+            label: '---',
+            value: 'separator',
+        },
+        {
+            label: 'Save and Exit',
+            value: 'save',
+        },
+        {
+            label: 'Exit without Saving',
+            value: 'exit',
+        },
+    ];
+    useInput((input, key) => {
+        if (step === 'capturing' && editingShortcut) {
+            // Capture the key combination
+            const newShortcut = {
+                key: key.escape ? 'escape' : input || '',
+                ctrl: key.ctrl || false,
+                alt: false, // Ink doesn't support alt
+                shift: false, // Ink doesn't support shift
+            };
+            // Check for reserved keys
+            if (key.ctrl && input === 'c') {
+                setError('Ctrl+C is reserved and cannot be used');
+                setStep('menu');
+                return;
+            }
+            if (key.ctrl && input === 'd') {
+                setError('Ctrl+D is reserved and cannot be used');
+                setStep('menu');
+                return;
+            }
+            if (key.ctrl && input === '[') {
+                setError('Ctrl+[ is reserved and cannot be used');
+                setStep('menu');
+                return;
+            }
+            // Validate that a modifier is used (except for escape)
+            if (!key.escape && !key.ctrl) {
+                setError('Shortcuts must use a modifier key (Ctrl)');
+                setStep('menu');
+                return;
+            }
+            setShortcuts({
+                ...shortcuts,
+                [editingShortcut]: newShortcut,
+            });
+            setError(null);
+            setStep('menu');
+        }
+        else if (step === 'menu') {
+            if (key.escape) {
+                onComplete();
+            }
+        }
+    });
+    const handleSelect = (item) => {
+        if (item.value === 'separator') {
+            return;
+        }
+        if (item.value === 'save') {
+            const success = shortcutManager.saveShortcuts(shortcuts);
+            if (success) {
+                onComplete();
+            }
+            else {
+                setError('Failed to save shortcuts');
+            }
+            return;
+        }
+        if (item.value === 'exit') {
+            onComplete();
+            return;
+        }
+        // Start editing a shortcut
+        setEditingShortcut(item.value);
+        setStep('capturing');
+        setError(null);
+    };
+    if (step === 'capturing') {
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { bold: true, color: "green" },
+                "Configure Shortcut: ",
+                editingShortcut),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, null, "Press the key combination you want to use")),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "Note: Shortcuts must use Ctrl as a modifier key")),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "Reserved: Ctrl+C, Ctrl+D, Ctrl+[ (Esc)"))));
+    }
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "green" }, "Configure Keyboard Shortcuts")),
+        error && (React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { color: "red" },
+                "Error: ",
+                error))),
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { dimColor: true }, "Select a shortcut to change:")),
+        React.createElement(SelectInput, { items: shortcutItems, onSelect: handleSelect, isFocused: true }),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true }, "Press Esc to exit without saving"))));
+};
+export default ConfigureShortcuts;

package/dist/components/Confirmation.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+interface ConfirmationProps {
+    message: string | React.ReactNode;
+    onConfirm: () => void;
+    onCancel: () => void;
+    confirmText?: string;
+    cancelText?: string;
+    confirmColor?: string;
+    cancelColor?: string;
+}
+declare const Confirmation: React.FC<ConfirmationProps>;
+export default Confirmation;

package/dist/components/Confirmation.js

@@ -0,0 +1,42 @@
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { shortcutManager } from '../services/shortcutManager.js';
+const Confirmation = ({ message, onConfirm, onCancel, confirmText = 'Yes', cancelText = 'No', confirmColor = 'green', cancelColor = 'red', }) => {
+    const [focused, setFocused] = useState(true); // true = confirm, false = cancel
+    useInput((input, key) => {
+        if (key.leftArrow || key.rightArrow) {
+            setFocused(!focused);
+        }
+        else if (key.return) {
+            if (focused) {
+                onConfirm();
+            }
+            else {
+                onCancel();
+            }
+        }
+        else if (shortcutManager.matchesShortcut('cancel', input, key)) {
+            onCancel();
+        }
+    });
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { marginBottom: 1 }, message),
+        React.createElement(Box, null,
+            React.createElement(Box, { marginRight: 2 },
+                React.createElement(Text, { color: focused ? confirmColor : 'white', inverse: focused },
+                    ' ',
+                    confirmText,
+                    ' ')),
+            React.createElement(Box, null,
+                React.createElement(Text, { color: !focused ? cancelColor : 'white', inverse: !focused },
+                    ' ',
+                    cancelText,
+                    ' '))),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true },
+                "Use \u2190 \u2192 to navigate, Enter to select,",
+                ' ',
+                shortcutManager.getShortcutDisplay('cancel'),
+                " to cancel"))));
+};
+export default Confirmation;

package/dist/components/DeleteWorktree.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface DeleteWorktreeProps {
+    onComplete: (worktreePaths: string[]) => void;
+    onCancel: () => void;
+}
+declare const DeleteWorktree: React.FC<DeleteWorktreeProps>;
+export default DeleteWorktree;