ccmanager 0.1.12 → 0.1.14

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/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,7 +1,7 @@
 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([]);
@@ -63,41 +63,14 @@ 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.length <= 10 ? (selectedWorktrees.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,
-                    selectedWorktrees.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 ",
-                        selectedWorktrees.length - 8,
-                        " more worktrees")))),
-            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 },

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.12",
+	"version": "0.1.14",
 	"description": "TUI application for managing multiple Claude Code sessions across Git worktrees",
 	"license": "MIT",
 	"author": "Kodai Kabasawa",