ccmanager 0.1.11 → 0.1.13

package/dist/components/App.js

@@ -126,13 +126,13 @@ const App = () => {
     const handleCancelNewWorktree = () => {
         handleReturnToMenu();
     };
-    const handleDeleteWorktrees = async (worktreePaths) => {
+    const handleDeleteWorktrees = async (worktreePaths, deleteBranch) => {
         setView('deleting-worktree');
         setError(null);
         // Delete the worktrees
         let hasError = false;
         for (const path of worktreePaths) {
-            const result = worktreeService.deleteWorktree(path);
+            const result = worktreeService.deleteWorktree(path, { deleteBranch });
             if (!result.success) {
                 hasError = true;
                 setError(result.error || 'Failed to delete worktree');

package/dist/components/Configuration.js

@@ -66,6 +66,6 @@ const Configuration = ({ onComplete }) => {
             React.createElement(Text, { bold: true, color: "green" }, "Configuration")),
         React.createElement(Box, { marginBottom: 1 },
             React.createElement(Text, { dimColor: true }, "Select a configuration option:")),
-        React.createElement(SelectInput, { items: menuItems, onSelect: handleSelect, isFocused: true })));
+        React.createElement(SelectInput, { items: menuItems, onSelect: handleSelect, isFocused: true, limit: 10 })));
 };
 export default Configuration;

package/dist/components/ConfigureHooks.js

@@ -126,7 +126,7 @@ const ConfigureHooks = ({ onComplete }) => {
             React.createElement(Text, { bold: true, color: "green" }, "Configure Status Change Hooks")),
         React.createElement(Box, { marginBottom: 1 },
             React.createElement(Text, { dimColor: true }, "Set commands to run when Claude Code session status changes:")),
-        React.createElement(SelectInput, { items: getMenuItems(), onSelect: handleMenuSelect, isFocused: true }),
+        React.createElement(SelectInput, { items: getMenuItems(), onSelect: handleMenuSelect, isFocused: true, limit: 10 }),
         React.createElement(Box, { marginTop: 1 },
             React.createElement(Text, { dimColor: true }, "Press Esc to go back"))));
 };

package/dist/components/ConfigureShortcuts.js

@@ -132,7 +132,7 @@ const ConfigureShortcuts = ({ onComplete, }) => {
                 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(SelectInput, { items: shortcutItems, onSelect: handleSelect, isFocused: true, limit: 10 }),
         React.createElement(Box, { marginTop: 1 },
             React.createElement(Text, { dimColor: true }, "Press Esc to exit without saving"))));
 };

package/dist/components/DeleteConfirmation.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+interface DeleteConfirmationProps {
+    worktrees: Array<{
+        path: string;
+        branch?: string;
+    }>;
+    onConfirm: (deleteBranch: boolean) => void;
+    onCancel: () => void;
+}
+declare const DeleteConfirmation: React.FC<DeleteConfirmationProps>;
+export default DeleteConfirmation;

package/dist/components/DeleteConfirmation.js

@@ -0,0 +1,133 @@
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { shortcutManager } from '../services/shortcutManager.js';
+const DeleteConfirmation = ({ worktrees, onConfirm, onCancel, }) => {
+    // Check if any worktrees have branches
+    const hasAnyBranches = worktrees.some(wt => wt.branch);
+    const [deleteBranch, setDeleteBranch] = useState(true);
+    const [focusedOption, setFocusedOption] = useState(hasAnyBranches ? 'deleteBranch' : 'confirm');
+    // Helper functions for navigation
+    const isRadioOption = (option) => option === 'deleteBranch' || option === 'keepBranch';
+    const isActionButton = (option) => option === 'confirm' || option === 'cancel';
+    const handleUpArrow = () => {
+        if (!hasAnyBranches) {
+            if (focusedOption === 'cancel')
+                setFocusedOption('confirm');
+            return;
+        }
+        const navigationMap = {
+            keepBranch: 'deleteBranch',
+            confirm: 'keepBranch',
+            cancel: 'keepBranch',
+        };
+        const next = navigationMap[focusedOption];
+        if (next)
+            setFocusedOption(next);
+    };
+    const handleDownArrow = () => {
+        if (!hasAnyBranches) {
+            if (focusedOption === 'confirm')
+                setFocusedOption('cancel');
+            return;
+        }
+        const navigationMap = {
+            deleteBranch: 'keepBranch',
+            keepBranch: 'confirm',
+            confirm: 'cancel',
+        };
+        const next = navigationMap[focusedOption];
+        if (next)
+            setFocusedOption(next);
+    };
+    const handleHorizontalArrow = (direction) => {
+        if (isActionButton(focusedOption)) {
+            setFocusedOption(direction === 'left' ? 'confirm' : 'cancel');
+        }
+    };
+    const handleSelect = () => {
+        if (isRadioOption(focusedOption)) {
+            setDeleteBranch(focusedOption === 'deleteBranch');
+        }
+        else if (focusedOption === 'confirm') {
+            onConfirm(deleteBranch);
+        }
+        else if (focusedOption === 'cancel') {
+            onCancel();
+        }
+    };
+    useInput((input, key) => {
+        if (key.upArrow) {
+            handleUpArrow();
+        }
+        else if (key.downArrow) {
+            handleDownArrow();
+        }
+        else if (key.leftArrow) {
+            handleHorizontalArrow('left');
+        }
+        else if (key.rightArrow) {
+            handleHorizontalArrow('right');
+        }
+        else if (input === ' ' && isRadioOption(focusedOption)) {
+            setDeleteBranch(focusedOption === 'deleteBranch');
+        }
+        else if (key.return) {
+            handleSelect();
+        }
+        else if (shortcutManager.matchesShortcut('cancel', input, key)) {
+            onCancel();
+        }
+    });
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Text, { bold: true, color: "red" }, "\u26A0\uFE0F Delete Confirmation"),
+        React.createElement(Box, { marginTop: 1, marginBottom: 1, flexDirection: "column" },
+            React.createElement(Text, null, "You are about to delete the following worktrees:"),
+            worktrees.length <= 10 ? (worktrees.map(wt => (React.createElement(Text, { key: wt.path, color: "red" },
+                "\u2022 ",
+                wt.branch ? wt.branch.replace('refs/heads/', '') : 'detached',
+                ' ',
+                "(",
+                wt.path,
+                ")")))) : (React.createElement(React.Fragment, null,
+                worktrees.slice(0, 8).map(wt => (React.createElement(Text, { key: wt.path, color: "red" },
+                    "\u2022",
+                    ' ',
+                    wt.branch ? wt.branch.replace('refs/heads/', '') : 'detached',
+                    ' ',
+                    "(",
+                    wt.path,
+                    ")"))),
+                React.createElement(Text, { color: "red", dimColor: true },
+                    "... and ",
+                    worktrees.length - 8,
+                    " more worktrees")))),
+        hasAnyBranches && (React.createElement(Box, { marginBottom: 1, flexDirection: "column" },
+            React.createElement(Text, { bold: true }, "What do you want to do with the associated branches?"),
+            React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                React.createElement(Box, null,
+                    React.createElement(Text, { color: focusedOption === 'deleteBranch' ? 'red' : undefined, inverse: focusedOption === 'deleteBranch' },
+                        deleteBranch ? '(•)' : '( )',
+                        " Delete the branches too")),
+                React.createElement(Box, null,
+                    React.createElement(Text, { color: focusedOption === 'keepBranch' ? 'green' : undefined, inverse: focusedOption === 'keepBranch' },
+                        !deleteBranch ? '(•)' : '( )',
+                        " Keep the branches"))))),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Box, { marginRight: 2 },
+                React.createElement(Text, { color: focusedOption === 'confirm' ? 'green' : 'white', inverse: focusedOption === 'confirm' },
+                    ' ',
+                    "Confirm",
+                    ' ')),
+            React.createElement(Box, null,
+                React.createElement(Text, { color: focusedOption === 'cancel' ? 'red' : 'white', inverse: focusedOption === 'cancel' },
+                    ' ',
+                    "Cancel",
+                    ' '))),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true },
+                "Use \u2191\u2193 to navigate options, Space/Enter to select,",
+                ' ',
+                shortcutManager.getShortcutDisplay('cancel'),
+                " to cancel"))));
+};
+export default DeleteConfirmation;

package/dist/components/DeleteWorktree.d.ts

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

package/dist/components/DeleteWorktree.js

@@ -1,13 +1,14 @@
 import React, { useState, useEffect } from 'react';
 import { Box, Text, useInput } from 'ink';
 import { WorktreeService } from '../services/worktreeService.js';
-import Confirmation from './Confirmation.js';
+import DeleteConfirmation from './DeleteConfirmation.js';
 import { shortcutManager } from '../services/shortcutManager.js';
 const DeleteWorktree = ({ onComplete, onCancel, }) => {
     const [worktrees, setWorktrees] = useState([]);
     const [selectedIndices, setSelectedIndices] = useState(new Set());
     const [focusedIndex, setFocusedIndex] = useState(0);
     const [confirmMode, setConfirmMode] = useState(false);
+    const VIEWPORT_SIZE = 10; // Maximum number of items to display at once
     useEffect(() => {
         const worktreeService = new WorktreeService();
         const allWorktrees = worktreeService.getWorktrees();
@@ -62,47 +63,51 @@ const DeleteWorktree = ({ onComplete, onCancel, }) => {
     }
     if (confirmMode) {
         const selectedWorktrees = Array.from(selectedIndices).map(index => worktrees[index]);
-        const handleConfirm = () => {
+        const handleConfirm = (deleteBranch) => {
             const selectedPaths = Array.from(selectedIndices).map(index => worktrees[index].path);
-            onComplete(selectedPaths);
+            onComplete(selectedPaths, deleteBranch);
         };
         const handleCancel = () => {
             setConfirmMode(false);
         };
-        const confirmMessage = (React.createElement(Box, { flexDirection: "column" },
-            React.createElement(Text, { bold: true, color: "red" }, "\u26A0\uFE0F Delete Confirmation"),
-            React.createElement(Box, { marginTop: 1, marginBottom: 1, flexDirection: "column" },
-                React.createElement(Text, null, "You are about to delete the following worktrees:"),
-                selectedWorktrees.map(wt => (React.createElement(Text, { key: wt.path, color: "red" },
-                    "\u2022 ",
-                    wt.branch ? wt.branch.replace('refs/heads/', '') : 'detached',
-                    ' ',
-                    "(",
-                    wt.path,
-                    ")")))),
-            React.createElement(Text, { bold: true }, "This will also delete their branches. Are you sure?")));
-        return (React.createElement(Confirmation, { message: confirmMessage, onConfirm: handleConfirm, onCancel: handleCancel }));
+        return (React.createElement(DeleteConfirmation, { worktrees: selectedWorktrees, onConfirm: handleConfirm, onCancel: handleCancel }));
     }
     return (React.createElement(Box, { flexDirection: "column" },
         React.createElement(Box, { marginBottom: 1 },
             React.createElement(Text, { bold: true, color: "red" }, "Delete Worktrees")),
         React.createElement(Box, { marginBottom: 1 },
             React.createElement(Text, { dimColor: true }, "Select worktrees to delete (Space to select, Enter to confirm):")),
-        worktrees.map((worktree, index) => {
-            const isSelected = selectedIndices.has(index);
-            const isFocused = index === focusedIndex;
-            const branchName = worktree.branch
-                ? worktree.branch.replace('refs/heads/', '')
-                : 'detached';
-            return (React.createElement(Box, { key: worktree.path },
-                React.createElement(Text, { color: isFocused ? 'green' : undefined, inverse: isFocused, dimColor: !isFocused && !isSelected },
-                    isSelected ? '[✓]' : '[ ]',
-                    " ",
-                    branchName,
-                    " (",
-                    worktree.path,
-                    ")")));
-        }),
+        (() => {
+            // Calculate viewport window
+            const viewportStart = Math.max(0, Math.min(focusedIndex - Math.floor(VIEWPORT_SIZE / 2), worktrees.length - VIEWPORT_SIZE));
+            const viewportEnd = Math.min(viewportStart + VIEWPORT_SIZE, worktrees.length);
+            const visibleWorktrees = worktrees.slice(viewportStart, viewportEnd);
+            return (React.createElement(React.Fragment, null,
+                viewportStart > 0 && (React.createElement(Text, { dimColor: true },
+                    "\u2191 ",
+                    viewportStart,
+                    " more...")),
+                visibleWorktrees.map((worktree, relativeIndex) => {
+                    const actualIndex = viewportStart + relativeIndex;
+                    const isSelected = selectedIndices.has(actualIndex);
+                    const isFocused = actualIndex === focusedIndex;
+                    const branchName = worktree.branch
+                        ? worktree.branch.replace('refs/heads/', '')
+                        : 'detached';
+                    return (React.createElement(Box, { key: worktree.path },
+                        React.createElement(Text, { color: isFocused ? 'green' : undefined, inverse: isFocused, dimColor: !isFocused && !isSelected },
+                            isSelected ? '[✓]' : '[ ]',
+                            " ",
+                            branchName,
+                            " (",
+                            worktree.path,
+                            ")")));
+                }),
+                viewportEnd < worktrees.length && (React.createElement(Text, { dimColor: true },
+                    "\u2193 ",
+                    worktrees.length - viewportEnd,
+                    " more..."))));
+        })(),
         React.createElement(Box, { marginTop: 1, flexDirection: "column" },
             React.createElement(Text, { dimColor: true },
                 "Controls: \u2191\u2193 Navigate, Space Select, Enter Confirm,",

package/dist/components/MergeWorktree.js

@@ -55,7 +55,7 @@ const MergeWorktree = ({ onComplete, onCancel, }) => {
                 React.createElement(Text, { bold: true, color: "green" }, "Merge Worktree")),
             React.createElement(Box, { marginBottom: 1 },
                 React.createElement(Text, null, "Select the source branch to merge:")),
-            React.createElement(SelectInput, { items: branchItems, onSelect: handleSelectSource, isFocused: true }),
+            React.createElement(SelectInput, { items: branchItems, onSelect: handleSelectSource, isFocused: true, limit: 10 }),
             React.createElement(Box, { marginTop: 1 },
                 React.createElement(Text, { dimColor: true },
                     "Press ",
@@ -72,7 +72,7 @@ const MergeWorktree = ({ onComplete, onCancel, }) => {
                     React.createElement(Text, { color: "yellow" }, sourceBranch))),
             React.createElement(Box, { marginBottom: 1 },
                 React.createElement(Text, null, "Select the target branch to merge into:")),
-            React.createElement(SelectInput, { items: branchItems, onSelect: handleSelectTarget, isFocused: true }),
+            React.createElement(SelectInput, { items: branchItems, onSelect: handleSelectTarget, isFocused: true, limit: 10 }),
             React.createElement(Box, { marginTop: 1 },
                 React.createElement(Text, { dimColor: true },
                     "Press ",

package/dist/components/NewWorktree.js

@@ -96,7 +96,7 @@ const NewWorktree = ({ onComplete, onCancel }) => {
                     "Select base branch for ",
                     React.createElement(Text, { color: "cyan" }, branch),
                     ":")),
-            React.createElement(SelectInput, { items: branchItems, onSelect: handleBaseBranchSelect, initialIndex: 0 }))),
+            React.createElement(SelectInput, { items: branchItems, onSelect: handleBaseBranchSelect, initialIndex: 0, limit: 10 }))),
         React.createElement(Box, { marginTop: 1 },
             React.createElement(Text, { dimColor: true },
                 "Press ",

package/dist/services/worktreeService.d.ts

@@ -13,7 +13,9 @@ export declare class WorktreeService {
         success: boolean;
         error?: string;
     };
-    deleteWorktree(worktreePath: string): {
+    deleteWorktree(worktreePath: string, options?: {
+        deleteBranch?: boolean;
+    }): {
         success: boolean;
         error?: string;
     };

package/dist/services/worktreeService.js

@@ -210,7 +210,7 @@ export class WorktreeService {
             };
         }
     }
-    deleteWorktree(worktreePath) {
+    deleteWorktree(worktreePath, options) {
         try {
             // Get the worktree info to find the branch
             const worktrees = this.getWorktrees();
@@ -232,19 +232,20 @@ export class WorktreeService {
                 cwd: this.rootPath,
                 encoding: 'utf8',
             });
-            // Delete the branch if it exists
-            const branchName = worktree.branch
-                ? worktree.branch.replace('refs/heads/', '')
-                : 'detached';
-            try {
-                execSync(`git branch -D "${branchName}"`, {
-                    cwd: this.rootPath,
-                    encoding: 'utf8',
-                });
-            }
-            catch {
-                // Branch might not exist or might be checked out elsewhere
-                // This is not a fatal error
+            // Delete the branch if requested (default to true for backward compatibility)
+            const deleteBranch = options?.deleteBranch ?? true;
+            if (deleteBranch && worktree.branch) {
+                const branchName = worktree.branch.replace('refs/heads/', '');
+                try {
+                    execSync(`git branch -D "${branchName}"`, {
+                        cwd: this.rootPath,
+                        encoding: 'utf8',
+                    });
+                }
+                catch {
+                    // Branch might not exist or might be checked out elsewhere
+                    // This is not a fatal error
+                }
             }
             return { success: true };
         }

package/package.json

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