ccmanager 3.10.0 → 3.11.1

package/dist/components/NewWorktree.js

@@ -9,18 +9,15 @@ import { generateWorktreeDirectory } from '../utils/worktreeUtils.js';
 import { WorktreeService } from '../services/worktreeService.js';
 import { useSearchMode } from '../hooks/useSearchMode.js';
 import { Effect } from 'effect';
+import { describePromptInjection, getPromptInjectionMethod, } from '../utils/presetPrompt.js';
 const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
     const worktreeConfig = configReader.getWorktreeConfig();
+    const presetsConfig = configReader.getCommandPresets();
     const isAutoDirectory = worktreeConfig.autoDirectory;
     const isAutoUseDefaultBranch = worktreeConfig.autoUseDefaultBranch ?? false;
     const limit = 10;
-    // Determine initial step based on config options
-    // If autoUseDefaultBranch is enabled, we start at a temporary 'loading' state
-    // and will transition to 'branch-strategy' after branches are loaded
     const getInitialStep = () => {
         if (isAutoDirectory) {
-            // With autoDirectory, skip path input
-            // If autoUseDefaultBranch is also enabled, we'll skip base-branch after loading
             return 'base-branch';
         }
         return 'path';
@@ -31,17 +28,16 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
     const [baseBranch, setBaseBranch] = useState('');
     const [copyClaudeDirectory, setCopyClaudeDirectory] = useState(true);
     const [copySessionData, setCopySessionData] = useState(worktreeConfig.copySessionData ?? true);
-    // Loading and error states for branch data
+    const [selectedPresetId, setSelectedPresetId] = useState(presetsConfig.defaultPresetId);
+    const [initialPrompt, setInitialPrompt] = useState('');
     const [isLoadingBranches, setIsLoadingBranches] = useState(true);
     const [branchLoadError, setBranchLoadError] = useState(null);
     const [branches, setBranches] = useState([]);
     const [defaultBranch, setDefaultBranch] = useState('main');
-    // Initialize worktree service and load branches using Effect
     useEffect(() => {
         let cancelled = false;
         const service = new WorktreeService(projectPath);
         const loadBranches = async () => {
-            // Use Effect.all to load branches and defaultBranch in parallel
             const workflow = Effect.all([service.getAllBranchesEffect(), service.getDefaultBranchEffect()], { concurrency: 2 });
             const result = await Effect.runPromise(Effect.match(workflow, {
                 onFailure: (error) => ({
@@ -63,13 +59,9 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
                     setBranches(result.branches);
                     setDefaultBranch(result.defaultBranch);
                     setIsLoadingBranches(false);
-                    // If autoUseDefaultBranch is enabled, auto-set the base branch
-                    // and skip to branch-strategy step
                     if (isAutoUseDefaultBranch && result.defaultBranch) {
                         setBaseBranch(result.defaultBranch);
-                        // Skip base-branch step, go directly to branch-strategy
-                        // (if we're at base-branch step, which happens with autoDirectory)
-                        setStep(currentStep => currentStep === 'base-branch' ? 'branch-strategy' : currentStep);
+                        setStep(currentStep => currentStep === 'base-branch' ? 'creation-mode' : currentStep);
                     }
                 }
             }
@@ -84,98 +76,142 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
             cancelled = true;
         };
     }, [projectPath, isAutoUseDefaultBranch]);
-    // Create branch items with default branch first (memoized)
     const allBranchItems = useMemo(() => [
         { label: `${defaultBranch} (default)`, value: defaultBranch },
         ...branches
             .filter(br => br !== defaultBranch)
             .map(br => ({ label: br, value: br })),
     ], [branches, defaultBranch]);
-    // Use search mode for base branch selection
     const { isSearchMode, searchQuery, selectedIndex, setSearchQuery } = useSearchMode(allBranchItems.length, {
         isDisabled: step !== 'base-branch',
     });
-    // Filter branch items based on search query
     const branchItems = useMemo(() => {
         if (!searchQuery)
             return allBranchItems;
         return allBranchItems.filter(item => item.value.toLowerCase().includes(searchQuery.toLowerCase()));
     }, [allBranchItems, searchQuery]);
+    const presetItems = useMemo(() => presetsConfig.presets.map(preset => ({
+        label: `${preset.name}${preset.id === presetsConfig.defaultPresetId ? ' (default)' : ''}\n    Command: ${preset.command}${preset.args?.length ? ` ${preset.args.join(' ')}` : ''}`,
+        value: preset.id,
+    })), [presetsConfig.defaultPresetId, presetsConfig.presets]);
+    const selectedPreset = useMemo(() => presetsConfig.presets.find(preset => preset.id === selectedPresetId) ||
+        presetsConfig.presets[0], [selectedPresetId, presetsConfig.presets]);
     useInput((input, key) => {
         if (shortcutManager.matchesShortcut('cancel', input, key)) {
             onCancel();
         }
-        // Handle arrow key navigation in search mode for base branch selection
         if (step === 'base-branch' && isSearchMode) {
-            // Don't handle any keys here - let useSearchMode handle them
-            // The hook will handle arrow keys for navigation and Enter to exit search mode
             return;
         }
     });
     const handlePathSubmit = (value) => {
-        if (value.trim()) {
-            setPath(value.trim());
-            // If autoUseDefaultBranch is enabled and we have the default branch,
-            // skip base-branch selection and go directly to branch-strategy
-            if (isAutoUseDefaultBranch && defaultBranch) {
-                setBaseBranch(defaultBranch);
-                setStep('branch-strategy');
-            }
-            else {
-                setStep('base-branch');
-            }
+        if (!value.trim())
+            return;
+        setPath(value.trim());
+        if (isAutoUseDefaultBranch && defaultBranch) {
+            setBaseBranch(defaultBranch);
+            setStep('creation-mode');
         }
-    };
-    const handleBranchSubmit = (value) => {
-        if (value.trim()) {
-            setBranch(value.trim());
-            setStep('copy-settings');
+        else {
+            setStep('base-branch');
         }
     };
     const handleBaseBranchSelect = (item) => {
         setBaseBranch(item.value);
-        setStep('branch-strategy');
+        setStep('creation-mode');
+    };
+    const handleCreationModeSelect = (item) => {
+        if (item.value === 'manual') {
+            setStep('branch-strategy');
+            return;
+        }
+        setStep('auto-preset');
     };
     const handleBranchStrategySelect = (item) => {
         const useExisting = item.value === 'existing';
         if (useExisting) {
-            // Use the base branch as the branch name for existing branch
             setBranch(baseBranch);
             setStep('copy-settings');
         }
         else {
-            // Need to input new branch name
             setStep('branch');
         }
     };
+    const handleBranchSubmit = (value) => {
+        if (!value.trim())
+            return;
+        setBranch(value.trim());
+        setStep('copy-settings');
+    };
+    const handlePresetSelect = (item) => {
+        setSelectedPresetId(item.value);
+        setStep('auto-prompt');
+    };
+    const handlePromptSubmit = (value) => {
+        if (!value.trim())
+            return;
+        setInitialPrompt(value.trim());
+        setStep('copy-settings');
+    };
     const handleCopySettingsSelect = (item) => {
         setCopyClaudeDirectory(item.value);
         setStep('copy-session');
     };
+    const getResolvedPath = () => {
+        if (!isAutoDirectory) {
+            return path;
+        }
+        const branchForPath = step === 'copy-session' && branch ? branch : 'generated-from-prompt';
+        return generateWorktreeDirectory(projectPath || process.cwd(), branchForPath, worktreeConfig.autoDirectoryPattern);
+    };
     const handleCopySessionSelect = (item) => {
         const shouldCopy = item.value === 'yes';
+        const resolvedPath = getResolvedPath();
         setCopySessionData(shouldCopy);
-        if (isAutoDirectory) {
-            // Generate path from branch name
-            const autoPath = generateWorktreeDirectory(projectPath || process.cwd(), branch, worktreeConfig.autoDirectoryPattern);
-            onComplete(autoPath, branch, baseBranch, shouldCopy, copyClaudeDirectory);
+        if (step !== 'copy-session') {
+            return;
         }
-        else {
-            onComplete(path, branch, baseBranch, shouldCopy, copyClaudeDirectory);
+        if (initialPrompt && selectedPresetId) {
+            onComplete({
+                creationMode: 'prompt',
+                path: isAutoDirectory ? projectPath || process.cwd() : resolvedPath,
+                projectPath: projectPath || process.cwd(),
+                autoDirectoryPattern: isAutoDirectory
+                    ? worktreeConfig.autoDirectoryPattern
+                    : undefined,
+                baseBranch,
+                presetId: selectedPresetId,
+                initialPrompt,
+                copySessionData: shouldCopy,
+                copyClaudeDirectory,
+            });
+            return;
         }
+        onComplete({
+            creationMode: 'manual',
+            path: resolvedPath,
+            branch,
+            baseBranch,
+            copySessionData: shouldCopy,
+            copyClaudeDirectory,
+        });
     };
-    // Calculate generated path for preview (memoized to avoid expensive recalculations)
     const generatedPath = useMemo(() => {
-        return isAutoDirectory && branch
-            ? generateWorktreeDirectory(projectPath || process.cwd(), branch, worktreeConfig.autoDirectoryPattern)
-            : '';
+        if (!isAutoDirectory) {
+            return '';
+        }
+        const branchForPath = branch || (initialPrompt ? 'generated-from-prompt' : '');
+        if (!branchForPath) {
+            return '';
+        }
+        return generateWorktreeDirectory(projectPath || process.cwd(), branchForPath, worktreeConfig.autoDirectoryPattern);
     }, [
         isAutoDirectory,
         branch,
+        initialPrompt,
         worktreeConfig.autoDirectoryPattern,
         projectPath,
     ]);
-    // Format errors using TaggedError discrimination
     const formatError = (error) => {
         switch (error._tag) {
             case 'GitError':
@@ -190,17 +226,28 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
                 return `Validation failed for ${error.field}: ${error.constraint}`;
         }
     };
-    // Show loading indicator while branches load
     if (isLoadingBranches) {
         return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "green", children: "Create New Worktree" }) }), _jsx(Box, { children: _jsx(Text, { children: "Loading branches..." }) }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Press ", shortcutManager.getShortcutDisplay('cancel'), " to cancel"] }) })] }));
     }
-    // Show error message if branch loading failed
     if (branchLoadError) {
         return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "green", children: "Create New Worktree" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: "red", children: "Error loading branches:" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: "red", children: branchLoadError }) }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Press ", shortcutManager.getShortcutDisplay('cancel'), " to go back"] }) })] }));
     }
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "green", children: "Create New Worktree" }) }), step === 'path' && !isAutoDirectory ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Enter worktree path (relative to repository root):" }) }), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '> ' }), _jsx(TextInputWrapper, { value: path, onChange: setPath, onSubmit: handlePathSubmit, placeholder: "e.g., ../myproject-feature" })] })] })) : null, step === 'base-branch' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Select base branch for the worktree:" }) }), isSearchMode && (_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { children: "Search: " }), _jsx(TextInputWrapper, { value: searchQuery, onChange: setSearchQuery, focus: true, placeholder: "Type to filter branches..." })] })), isSearchMode && branchItems.length === 0 ? (_jsx(Box, { children: _jsx(Text, { color: "yellow", children: "No branches match your search" }) })) : isSearchMode ? (
-                    // In search mode, show the items as a list without SelectInput
-                    _jsx(Box, { flexDirection: "column", children: branchItems.slice(0, limit).map((item, index) => (_jsxs(Text, { color: index === selectedIndex ? 'green' : undefined, children: [index === selectedIndex ? '❯ ' : '  ', item.label] }, item.value))) })) : (_jsx(SelectInput, { items: branchItems, onSelect: handleBaseBranchSelect, initialIndex: selectedIndex, limit: limit, isFocused: !isSearchMode })), !isSearchMode && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press / to search" }) }))] })), step === 'branch-strategy' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Base branch: ", _jsx(Text, { color: "cyan", children: baseBranch })] }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Choose branch creation strategy:" }) }), _jsx(SelectInput, { items: [
+    const promptHandlingText = selectedPreset
+        ? describePromptInjection(selectedPreset)
+        : '';
+    const promptMethod = selectedPreset
+        ? getPromptInjectionMethod(selectedPreset)
+        : 'stdin';
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "green", children: "Create New Worktree" }) }), step === 'path' && !isAutoDirectory ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Enter worktree path (relative to repository root):" }) }), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '> ' }), _jsx(TextInputWrapper, { value: path, onChange: setPath, onSubmit: handlePathSubmit, placeholder: "e.g., ../myproject-feature" })] })] })) : null, step === 'base-branch' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Select base branch for the worktree:" }) }), isSearchMode && (_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { children: "Search: " }), _jsx(TextInputWrapper, { value: searchQuery, onChange: setSearchQuery, focus: true, placeholder: "Type to filter branches..." })] })), isSearchMode && branchItems.length === 0 ? (_jsx(Box, { children: _jsx(Text, { color: "yellow", children: "No branches match your search" }) })) : isSearchMode ? (_jsx(Box, { flexDirection: "column", children: branchItems.slice(0, limit).map((item, index) => (_jsxs(Text, { color: index === selectedIndex ? 'green' : undefined, children: [index === selectedIndex ? '❯ ' : '  ', item.label] }, item.value))) })) : (_jsx(SelectInput, { items: branchItems, onSelect: handleBaseBranchSelect, initialIndex: selectedIndex, limit: limit, isFocused: !isSearchMode })), !isSearchMode && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press / to search" }) }))] })), step === 'creation-mode' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Base branch: ", _jsx(Text, { color: "cyan", children: baseBranch })] }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "How do you want to create the new worktree?" }) }), _jsx(SelectInput, { items: [
+                            {
+                                label: '1. Choose the branch name yourself',
+                                value: 'manual',
+                            },
+                            {
+                                label: '2. Enter a prompt first and let Claude decide the branch name',
+                                value: 'prompt',
+                            },
+                        ], onSelect: handleCreationModeSelect, initialIndex: 0 })] })), step === 'branch-strategy' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Base branch: ", _jsx(Text, { color: "cyan", children: baseBranch })] }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Choose branch creation strategy:" }) }), _jsx(SelectInput, { items: [
                             {
                                 label: 'Create new branch from base branch',
                                 value: 'new',
@@ -209,13 +256,13 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
                                 label: 'Use existing base branch',
                                 value: 'existing',
                             },
-                        ], onSelect: handleBranchStrategySelect, initialIndex: 0 })] })), step === 'branch' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Enter new branch name (will be created from", ' ', _jsx(Text, { color: "cyan", children: baseBranch }), "):"] }) }), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '> ' }), _jsx(TextInputWrapper, { value: branch, onChange: setBranch, onSubmit: handleBranchSubmit, placeholder: "e.g., feature/new-feature" })] }), isAutoDirectory && generatedPath && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Worktree will be created at:", ' ', _jsx(Text, { color: "green", children: generatedPath })] }) }))] })), step === 'copy-settings' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Copy .claude directory from base branch (", _jsx(Text, { color: "cyan", children: baseBranch }), ")?"] }) }), _jsx(SelectInput, { items: [
+                        ], onSelect: handleBranchStrategySelect, initialIndex: 0 })] })), step === 'branch' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Enter new branch name (will be created from", ' ', _jsx(Text, { color: "cyan", children: baseBranch }), "):"] }) }), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '> ' }), _jsx(TextInputWrapper, { value: branch, onChange: setBranch, onSubmit: handleBranchSubmit, placeholder: "e.g., feature/new-feature" })] }), isAutoDirectory && generatedPath && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Worktree will be created at:", ' ', _jsx(Text, { color: "green", children: generatedPath })] }) }))] })), step === 'auto-preset' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Select the preset to use for the first session:" }) }), _jsx(SelectInput, { items: presetItems, onSelect: handlePresetSelect, initialIndex: Math.max(0, presetItems.findIndex(item => item.value === selectedPresetId)) })] })), step === 'auto-prompt' && selectedPreset && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Preset: ", _jsx(Text, { color: "cyan", children: selectedPreset.name })] }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Enter the prompt for the new session:" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: promptHandlingText }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Examples: Claude/Codex use the final argument, OpenCode uses `--prompt`, and other commands may receive the prompt over stdin." }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: "yellow", children: "Automatic branch naming requires the `claude` command in your PATH." }) }), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '> ' }), _jsx(TextInputWrapper, { value: initialPrompt, onChange: setInitialPrompt, onSubmit: handlePromptSubmit, placeholder: "Describe what you want the agent to do" })] }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Prompt delivery mode for this preset:", ' ', _jsx(Text, { color: "green", children: promptMethod })] }) })] })), step === 'copy-settings' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Copy .claude directory from base branch (", _jsx(Text, { color: "cyan", children: baseBranch }), ")?"] }) }), initialPrompt ? (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "The branch name will be generated automatically right before the worktree is created." }) })) : null, _jsx(SelectInput, { items: [
                             {
                                 label: 'Yes - Copy .claude directory from base branch',
                                 value: true,
                             },
                             { label: 'No - Start without .claude directory', value: false },
-                        ], onSelect: handleCopySettingsSelect, initialIndex: 0 })] })), step === 'copy-session' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Copy Claude Code session data to the new worktree?" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "This will copy conversation history and context from the current worktree" }) }), _jsx(SelectInput, { items: [
+                        ], onSelect: handleCopySettingsSelect, initialIndex: 0 })] })), step === 'copy-session' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Copy Claude Code session data to the new worktree?" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "This will copy conversation history and context from the current worktree." }) }), isAutoDirectory && generatedPath ? (_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { dimColor: true, children: ["Worktree path preview:", ' ', _jsx(Text, { color: "green", children: generatedPath })] }) })) : null, _jsx(SelectInput, { items: [
                             { label: '✅ Yes, copy session data', value: 'yes' },
                             { label: '❌ No, start fresh', value: 'no' },
                         ], onSelect: handleCopySessionSelect, initialIndex: copySessionData ? 0 : 1 })] })), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Press ", shortcutManager.getShortcutDisplay('cancel'), " to cancel"] }) })] }));

package/dist/components/NewWorktree.test.js

@@ -50,6 +50,18 @@ vi.mock('../services/config/configReader.js', () => ({
             autoDirectoryPattern: '../{project}-{branch}',
             copySessionData: true,
         }),
+        getCommandPresets: () => ({
+            presets: [
+                {
+                    id: 'claude',
+                    name: 'Claude',
+                    command: 'claude',
+                    args: ['--resume'],
+                    detectionStrategy: 'claude',
+                },
+            ],
+            defaultPresetId: 'claude',
+        }),
     },
 }));
 vi.mock('../hooks/useSearchMode.js', () => ({
@@ -259,7 +271,7 @@ describe('NewWorktree component Effect integration', () => {
         // Verify Effect was executed (Effect.match pattern)
         expect(effectExecuted).toBe(true);
     });
-    it('should skip base branch selection when autoUseDefaultBranch is enabled with autoDirectory', async () => {
+    it('should skip base branch selection and show creation mode when autoUseDefaultBranch is enabled with autoDirectory', async () => {
         const { Effect } = await import('effect');
         const { WorktreeService } = await import('../services/worktreeService.js');
         const { configReader } = await import('../services/config/configReader.js');
@@ -285,12 +297,13 @@ describe('NewWorktree component Effect integration', () => {
         // Wait for Effect to execute and state to update
         await new Promise(resolve => setTimeout(resolve, 100));
         const output = lastFrame();
-        // Should skip base-branch step and show branch-strategy step
-        // which displays "Base branch:" and "Choose branch creation strategy"
+        // Should skip base-branch step and show the manual/prompt creation mode choice
         expect(output).toContain('Create New Worktree');
         expect(output).toContain('Base branch:');
         expect(output).toContain('main');
-        expect(output).toContain('Choose branch creation strategy');
+        expect(output).toContain('How do you want to create the new worktree?');
+        expect(output).toContain('Choose the branch name yourself');
+        expect(output).toContain('Enter a prompt first');
     });
     it('should show base branch selection when autoUseDefaultBranch is disabled', async () => {
         const { Effect } = await import('effect');

package/dist/components/TextInputWrapper.d.ts

@@ -5,9 +5,6 @@ interface TextInputWrapperProps {
     onSubmit?: (value: string) => void;
     placeholder?: string;
     focus?: boolean;
-    mask?: string;
-    showCursor?: boolean;
-    highlightPastedText?: boolean;
 }
 declare const TextInputWrapper: React.FC<TextInputWrapperProps>;
 export default TextInputWrapper;

package/dist/components/TextInputWrapper.js

@@ -1,15 +1,124 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import TextInput from 'ink-text-input';
+import { useReducer, useEffect, useRef, useMemo, } from 'react';
+import { Text, useInput } from 'ink';
+import chalk from 'chalk';
 import stripAnsi from 'strip-ansi';
-const TextInputWrapper = ({ value, onChange, ...props }) => {
-    const handleChange = (newValue) => {
-        // First strip all ANSI escape sequences
-        let cleanedValue = stripAnsi(newValue);
-        // Then specifically remove bracketed paste mode markers that might remain
-        // These sometimes appear as literal text after ANSI stripping
-        cleanedValue = cleanedValue.replace(/\[200~/g, '').replace(/\[201~/g, '');
-        onChange(cleanedValue);
-    };
-    return _jsx(TextInput, { value: value, onChange: handleChange, ...props });
+const reducer = (state, action) => {
+    switch (action.type) {
+        case 'move-cursor-left': {
+            return {
+                ...state,
+                cursorOffset: Math.max(0, state.cursorOffset - 1),
+            };
+        }
+        case 'move-cursor-right': {
+            return {
+                ...state,
+                cursorOffset: Math.min(state.value.length, state.cursorOffset + 1),
+            };
+        }
+        case 'insert': {
+            return {
+                value: state.value.slice(0, state.cursorOffset) +
+                    action.text +
+                    state.value.slice(state.cursorOffset),
+                cursorOffset: state.cursorOffset + action.text.length,
+            };
+        }
+        case 'delete': {
+            if (state.cursorOffset === 0)
+                return state;
+            const newOffset = state.cursorOffset - 1;
+            return {
+                value: state.value.slice(0, newOffset) + state.value.slice(newOffset + 1),
+                cursorOffset: newOffset,
+            };
+        }
+        case 'set': {
+            return {
+                value: action.value,
+                cursorOffset: action.value.length,
+            };
+        }
+    }
+};
+function cleanInput(input) {
+    let cleaned = stripAnsi(input);
+    cleaned = cleaned.replace(/\[200~/g, '').replace(/\[201~/g, '');
+    return cleaned;
+}
+const cursor = chalk.inverse(' ');
+const TextInputWrapper = ({ value, onChange, onSubmit, placeholder = '', focus = true, }) => {
+    const [state, dispatch] = useReducer(reducer, {
+        value,
+        cursorOffset: value.length,
+    });
+    const lastReportedValue = useRef(value);
+    // Sync external value changes into internal state
+    useEffect(() => {
+        if (value !== lastReportedValue.current) {
+            lastReportedValue.current = value;
+            dispatch({ type: 'set', value });
+        }
+    }, [value]);
+    // Report internal state changes to parent
+    useEffect(() => {
+        if (state.value !== lastReportedValue.current) {
+            lastReportedValue.current = state.value;
+            onChange(state.value);
+        }
+    }, [state.value, onChange]);
+    useInput((input, key) => {
+        if (key.upArrow ||
+            key.downArrow ||
+            (key.ctrl && input === 'c') ||
+            key.tab ||
+            (key.shift && key.tab)) {
+            return;
+        }
+        if (key.return) {
+            onSubmit?.(state.value);
+            return;
+        }
+        if (key.leftArrow) {
+            dispatch({ type: 'move-cursor-left' });
+        }
+        else if (key.rightArrow) {
+            dispatch({ type: 'move-cursor-right' });
+        }
+        else if (key.backspace || key.delete) {
+            dispatch({ type: 'delete' });
+        }
+        else {
+            const cleaned = cleanInput(input);
+            if (cleaned) {
+                dispatch({ type: 'insert', text: cleaned });
+            }
+        }
+    }, { isActive: focus });
+    const renderedPlaceholder = useMemo(() => {
+        if (!focus) {
+            return placeholder ? chalk.dim(placeholder) : '';
+        }
+        return placeholder.length > 0
+            ? chalk.inverse(placeholder[0]) + chalk.dim(placeholder.slice(1))
+            : cursor;
+    }, [focus, placeholder]);
+    const renderedValue = useMemo(() => {
+        if (!focus) {
+            return state.value;
+        }
+        let result = state.value.length > 0 ? '' : cursor;
+        let index = 0;
+        for (const char of state.value) {
+            result += index === state.cursorOffset ? chalk.inverse(char) : char;
+            index++;
+        }
+        if (state.value.length > 0 && state.cursorOffset === state.value.length) {
+            result += cursor;
+        }
+        return result;
+    }, [focus, state.value, state.cursorOffset]);
+    return (_jsx(Text, { children: state.value.length > 0 ? renderedValue : renderedPlaceholder }));
 };
 export default TextInputWrapper;

package/dist/services/sessionManager.d.ts

@@ -17,6 +17,7 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private busyTimers;
     private autoApprovalDisabledWorktrees;
     private spawn;
+    private resolvePreset;
     detectTerminalState(session: Session): SessionState;
     detectBackgroundTask(session: Session): number;
     detectTeamMembers(session: Session): number;
@@ -54,7 +55,7 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
      * );
      * ```
      */
-    createSessionWithPresetEffect(worktreePath: string, presetId?: string): Effect.Effect<Session, ProcessError | ConfigError, never>;
+    createSessionWithPresetEffect(worktreePath: string, presetId?: string, initialPrompt?: string): Effect.Effect<Session, ProcessError | ConfigError, never>;
     private setupDataHandler;
     /**
      * Sets up exit handler for the session process.
@@ -95,7 +96,7 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
      * Create session with devcontainer integration using Effect-based error handling
      * @returns Effect that may fail with ProcessError (container/spawn failure) or ConfigError (invalid preset)
      */
-    createSessionWithDevcontainerEffect(worktreePath: string, devcontainerConfig: DevcontainerConfig, presetId?: string): Effect.Effect<Session, ProcessError | ConfigError, never>;
+    createSessionWithDevcontainerEffect(worktreePath: string, devcontainerConfig: DevcontainerConfig, presetId?: string, initialPrompt?: string): Effect.Effect<Session, ProcessError | ConfigError, never>;
     destroy(): void;
     static getSessionCounts(sessions: Session[]): SessionCounts;
     static formatSessionCounts(counts: SessionCounts): string;

package/dist/services/sessionManager.js

@@ -16,6 +16,7 @@ import { Mutex, createInitialSessionStateData } from '../utils/mutex.js';
 import { getBackgroundTaskTag, getTeamMemberTag, } from '../constants/statusIcons.js';
 import { getTerminalScreenContent } from '../utils/screenCapture.js';
 import { injectTeammateMode } from '../utils/commandArgs.js';
+import { preparePresetLaunch } from '../utils/presetPrompt.js';
 const { Terminal } = pkg;
 const execAsync = promisify(exec);
 const TERMINAL_CONTENT_MAX_LINES = 300;
@@ -34,6 +35,24 @@ export class SessionManager extends EventEmitter {
         };
         return spawn(command, args, spawnOptions);
     }
+    resolvePreset(presetId) {
+        let preset = presetId
+            ? Either.getOrElse(configReader.getPresetByIdEffect(presetId), () => null)
+            : null;
+        if (!preset) {
+            preset = configReader.getDefaultPreset();
+        }
+        if (!preset) {
+            throw new ConfigError({
+                configPath: 'configuration',
+                reason: 'validation',
+                details: presetId
+                    ? `Preset with ID '${presetId}' not found and no default preset available`
+                    : 'No default preset available',
+            });
+        }
+        return preset;
+    }
     detectTerminalState(session) {
         const stateData = session.stateMutex.getSnapshot();
         const detectedState = session.stateDetector.detectState(session.terminal, stateData.state);
@@ -227,7 +246,7 @@ export class SessionManager extends EventEmitter {
      * );
      * ```
      */
-    createSessionWithPresetEffect(worktreePath, presetId) {
+    createSessionWithPresetEffect(worktreePath, presetId, initialPrompt) {
         return Effect.tryPromise({
             try: async () => {
                 // Check if session already exists
@@ -235,31 +254,20 @@ export class SessionManager extends EventEmitter {
                 if (existing) {
                     return existing;
                 }
-                // Get preset configuration using Either-based lookup
-                let preset = presetId
-                    ? Either.getOrElse(configReader.getPresetByIdEffect(presetId), () => null)
-                    : null;
-                if (!preset) {
-                    preset = configReader.getDefaultPreset();
-                }
-                // Validate preset exists
-                if (!preset) {
-                    throw new ConfigError({
-                        configPath: 'configuration',
-                        reason: 'validation',
-                        details: presetId
-                            ? `Preset with ID '${presetId}' not found and no default preset available`
-                            : 'No default preset available',
-                    });
-                }
+                const preset = this.resolvePreset(presetId);
                 const command = preset.command;
-                const args = injectTeammateMode(preset.command, preset.args || [], preset.detectionStrategy);
+                const launch = preparePresetLaunch(preset, initialPrompt);
+                const args = launch.args;
                 // Spawn the process - fallback will be handled by setupExitHandler
                 const ptyProcess = await this.spawn(command, args, worktreePath);
-                return this.createSessionInternal(worktreePath, ptyProcess, {
+                const session = await this.createSessionInternal(worktreePath, ptyProcess, {
                     isPrimaryCommand: true,
                     detectionStrategy: preset.detectionStrategy,
                 });
+                if (launch.stdinPayload) {
+                    session.process.write(launch.stdinPayload);
+                }
+                return session;
             },
             catch: (error) => {
                 // If it's already a ConfigError, return it
@@ -617,7 +625,7 @@ export class SessionManager extends EventEmitter {
      * Create session with devcontainer integration using Effect-based error handling
      * @returns Effect that may fail with ProcessError (container/spawn failure) or ConfigError (invalid preset)
      */
-    createSessionWithDevcontainerEffect(worktreePath, devcontainerConfig, presetId) {
+    createSessionWithDevcontainerEffect(worktreePath, devcontainerConfig, presetId, initialPrompt) {
         return Effect.tryPromise({
             try: async () => {
                 // Check if session already exists
@@ -635,37 +643,26 @@ export class SessionManager extends EventEmitter {
                         message: `Failed to start devcontainer: ${error instanceof Error ? error.message : String(error)}`,
                     });
                 }
-                // Get preset configuration using Either-based lookup
-                let preset = presetId
-                    ? Either.getOrElse(configReader.getPresetByIdEffect(presetId), () => null)
-                    : null;
-                if (!preset) {
-                    preset = configReader.getDefaultPreset();
-                }
-                // Validate preset exists
-                if (!preset) {
-                    throw new ConfigError({
-                        configPath: 'configuration',
-                        reason: 'validation',
-                        details: presetId
-                            ? `Preset with ID '${presetId}' not found and no default preset available`
-                            : 'No default preset available',
-                    });
-                }
+                const preset = this.resolvePreset(presetId);
                 // Parse the exec command to extract arguments
                 const execParts = devcontainerConfig.execCommand.split(/\s+/);
                 const devcontainerCmd = execParts[0] || 'devcontainer';
                 const execArgs = execParts.slice(1);
                 // Build the full command: devcontainer exec [args] -- [preset command] [preset args]
-                const presetArgs = injectTeammateMode(preset.command, preset.args || [], preset.detectionStrategy);
+                const launch = preparePresetLaunch(preset, initialPrompt);
+                const presetArgs = launch.args;
                 const fullArgs = [...execArgs, '--', preset.command, ...presetArgs];
                 // Spawn the process within devcontainer
                 const ptyProcess = await this.spawn(devcontainerCmd, fullArgs, worktreePath);
-                return this.createSessionInternal(worktreePath, ptyProcess, {
+                const session = await this.createSessionInternal(worktreePath, ptyProcess, {
                     isPrimaryCommand: true,
                     detectionStrategy: preset.detectionStrategy,
                     devcontainerConfig,
                 });
+                if (launch.stdinPayload) {
+                    session.process.write(launch.stdinPayload);
+                }
+                return session;
             },
             catch: (error) => {
                 // If it's already a ConfigError or ProcessError, return it