ccmanager 3.10.0 → 3.11.1

package/dist/components/App.js

@@ -14,11 +14,13 @@ import RemoteBranchSelector from './RemoteBranchSelector.js';
 import LoadingSpinner from './LoadingSpinner.js';
 import { globalSessionOrchestrator } from '../services/globalSessionOrchestrator.js';
 import { WorktreeService } from '../services/worktreeService.js';
+import { worktreeNameGenerator } from '../services/worktreeNameGenerator.js';
 import { AmbiguousBranchError, } from '../types/index.js';
 import { configReader } from '../services/config/configReader.js';
 import { ENV_VARS } from '../constants/env.js';
 import { MULTI_PROJECT_ERRORS } from '../constants/error.js';
 import { projectManager } from '../services/projectManager.js';
+import { generateWorktreeDirectory } from '../utils/worktreeUtils.js';
 const App = ({ devcontainerConfig, multiProject, version, }) => {
     const { exit } = useApp();
     const [view, setView] = useState(multiProject ? 'project-list' : 'menu');
@@ -30,6 +32,7 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
     const [selectedWorktree, setSelectedWorktree] = useState(null); // Store selected worktree for preset selection
     const [selectedProject, setSelectedProject] = useState(null); // Store selected project in multi-project mode
     const [configScope, setConfigScope] = useState('global'); // Store config scope for configuration view
+    const [pendingMenuSessionLaunch, setPendingMenuSessionLaunch] = useState(null);
     // State for remote branch disambiguation
     const [pendingWorktreeCreation, setPendingWorktreeCreation] = useState(null);
     // State for loading context - track flags for message composition
@@ -50,26 +53,24 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
         }
     };
     // Helper function to create session with Effect-based error handling
-    const createSessionWithEffect = async (worktreePath, presetId) => {
+    const createSessionWithEffect = useCallback(async (worktreePath, presetId, initialPrompt) => {
         const sessionEffect = devcontainerConfig
-            ? sessionManager.createSessionWithDevcontainerEffect(worktreePath, devcontainerConfig, presetId)
-            : sessionManager.createSessionWithPresetEffect(worktreePath, presetId);
+            ? sessionManager.createSessionWithDevcontainerEffect(worktreePath, devcontainerConfig, presetId, initialPrompt)
+            : sessionManager.createSessionWithPresetEffect(worktreePath, presetId, initialPrompt);
         // Execute the Effect and handle both success and failure cases
         const result = await Effect.runPromise(Effect.either(sessionEffect));
         if (result._tag === 'Left') {
-            // Handle error using pattern matching on _tag
             const errorMessage = formatErrorMessage(result.left);
             return {
                 success: false,
                 errorMessage: `Failed to create session: ${errorMessage}`,
             };
         }
-        // Success case - extract session from Right
         return {
             success: true,
             session: result.right,
         };
-    };
+    }, [sessionManager, devcontainerConfig]);
     // Helper function to clear terminal screen
     const clearScreen = () => {
         if (process.stdout.isTTY) {
@@ -86,6 +87,38 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
                 callback();
         }, 10); // Small delay to ensure screen clear is processed
     }, []);
+    const navigateToSession = useCallback((session) => {
+        clearScreen();
+        setView('clearing');
+        setTimeout(() => {
+            setActiveSession(session);
+            setView('session');
+        }, 10);
+    }, []);
+    const startSessionForWorktree = useCallback(async (worktree, options) => {
+        let session = sessionManager.getSession(worktree.path);
+        if (!session) {
+            if (!options?.presetId && configReader.getSelectPresetOnStart()) {
+                setSelectedWorktree(worktree);
+                navigateWithClear('preset-selector');
+                return;
+            }
+            setView(options?.presetId ? 'creating-session-preset' : 'creating-session');
+            const result = await createSessionWithEffect(worktree.path, options?.presetId, options?.initialPrompt);
+            if (!result.success) {
+                setError(result.errorMessage);
+                navigateWithClear('menu');
+                return;
+            }
+            session = result.session;
+        }
+        navigateToSession(session);
+    }, [
+        sessionManager,
+        navigateWithClear,
+        navigateToSession,
+        createSessionWithEffect,
+    ]);
     useEffect(() => {
         // Listen for session exits to return to menu automatically
         const handleSessionExit = (session) => {
@@ -115,6 +148,26 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
             // Don't destroy sessions on unmount - they persist in memory
         };
     }, [sessionManager, multiProject, selectedProject, navigateWithClear]);
+    useEffect(() => {
+        if (view !== 'menu' || !pendingMenuSessionLaunch) {
+            return;
+        }
+        let cancelled = false;
+        void (async () => {
+            if (cancelled) {
+                return;
+            }
+            const launchRequest = pendingMenuSessionLaunch;
+            setPendingMenuSessionLaunch(null);
+            await startSessionForWorktree(launchRequest.worktree, {
+                presetId: launchRequest.presetId,
+                initialPrompt: launchRequest.initialPrompt,
+            });
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [view, pendingMenuSessionLaunch, startSessionForWorktree]);
     // Helper function to parse ambiguous branch error and create AmbiguousBranchError
     const parseAmbiguousBranchError = (errorMessage) => {
         const pattern = /Ambiguous branch '(.+?)' found in multiple remotes: (.+?)\. Please specify which remote to use\./;
@@ -141,6 +194,20 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
     // Helper function to handle worktree creation results
     const handleWorktreeCreationResult = (result, creationData) => {
         if (result.success) {
+            if (creationData.presetId && creationData.initialPrompt) {
+                setPendingMenuSessionLaunch({
+                    worktree: {
+                        path: creationData.path,
+                        branch: creationData.branch,
+                        isMainWorktree: false,
+                        hasSession: false,
+                    },
+                    presetId: creationData.presetId,
+                    initialPrompt: creationData.initialPrompt,
+                });
+                handleReturnToMenu();
+                return;
+            }
             handleReturnToMenu();
             return;
         }
@@ -207,28 +274,7 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
             }
             return;
         }
-        // Get or create session for this worktree
-        let session = sessionManager.getSession(worktree.path);
-        if (!session) {
-            // Check if we should show preset selector
-            if (configReader.getSelectPresetOnStart()) {
-                setSelectedWorktree(worktree);
-                navigateWithClear('preset-selector');
-                return;
-            }
-            // Set loading state before async operation
-            setView('creating-session');
-            // Use Effect-based session creation with default preset
-            const result = await createSessionWithEffect(worktree.path);
-            if (!result.success) {
-                setError(result.errorMessage);
-                navigateWithClear('menu');
-                return;
-            }
-            session = result.session;
-        }
-        setActiveSession(session);
-        navigateWithClear('session');
+        await startSessionForWorktree(worktree);
     };
     const handlePresetSelected = async (presetId) => {
         if (!selectedWorktree)
@@ -244,8 +290,7 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
             return;
         }
         // Success case
-        setActiveSession(result.session);
-        navigateWithClear('session');
+        navigateToSession(result.session);
         setSelectedWorktree(null);
     };
     const handlePresetSelectorCancel = () => {
@@ -267,22 +312,69 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
             // Ink's useInput in Menu will reconfigure stdin automatically
         });
     };
-    const handleCreateWorktree = async (path, branch, baseBranch, copySessionData, copyClaudeDirectory) => {
+    const handleCreateWorktree = async (request) => {
+        setError(null);
+        let branch = request.creationMode === 'manual' ? request.branch : '';
+        let targetPath = request.path;
+        if (request.creationMode === 'prompt') {
+            setLoadingContext({
+                copySessionData: request.copySessionData,
+                isPromptFlow: true,
+                stage: 'naming',
+            });
+            setView('creating-worktree');
+            const allBranches = await Effect.runPromise(Effect.either(worktreeService.getAllBranchesEffect()));
+            const existingBranches = allBranches._tag === 'Right' ? allBranches.right : [];
+            const generatedBranch = await Effect.runPromise(Effect.either(worktreeNameGenerator.generateBranchNameEffect(request.initialPrompt, request.baseBranch, existingBranches)));
+            if (generatedBranch._tag === 'Left') {
+                setError(formatErrorMessage(generatedBranch.left));
+                setView('new-worktree');
+                return;
+            }
+            branch = generatedBranch.right;
+            if (request.autoDirectoryPattern) {
+                targetPath = generateWorktreeDirectory(request.projectPath, branch, request.autoDirectoryPattern);
+            }
+        }
         // Set loading context before showing loading view
-        setLoadingContext({ copySessionData });
+        setLoadingContext({
+            copySessionData: request.copySessionData,
+            isPromptFlow: request.creationMode === 'prompt',
+            stage: 'creating',
+        });
         setView('creating-worktree');
-        setError(null);
         // Create the worktree using Effect
-        const result = await Effect.runPromise(Effect.either(worktreeService.createWorktreeEffect(path, branch, baseBranch, copySessionData, copyClaudeDirectory)));
+        const result = await Effect.runPromise(Effect.either(worktreeService.createWorktreeEffect(targetPath, branch, request.baseBranch, request.copySessionData, request.copyClaudeDirectory)));
         // Transform Effect result to legacy format for handleWorktreeCreationResult
         if (result._tag === 'Left') {
             // Handle error using pattern matching on _tag
             const errorMessage = formatErrorMessage(result.left);
-            handleWorktreeCreationResult({ success: false, error: errorMessage }, { path, branch, baseBranch, copySessionData, copyClaudeDirectory });
+            handleWorktreeCreationResult({ success: false, error: errorMessage }, {
+                path: targetPath,
+                branch,
+                baseBranch: request.baseBranch,
+                copySessionData: request.copySessionData,
+                copyClaudeDirectory: request.copyClaudeDirectory,
+                presetId: request.creationMode === 'prompt' ? request.presetId : undefined,
+                initialPrompt: request.creationMode === 'prompt'
+                    ? request.initialPrompt
+                    : undefined,
+            });
         }
         else {
             // Success case
-            handleWorktreeCreationResult({ success: true }, { path, branch, baseBranch, copySessionData, copyClaudeDirectory });
+            const createdWorktree = result.right;
+            handleWorktreeCreationResult({ success: true }, {
+                path: createdWorktree.path,
+                branch: createdWorktree.branch || branch,
+                baseBranch: request.baseBranch,
+                copySessionData: request.copySessionData,
+                copyClaudeDirectory: request.copyClaudeDirectory,
+                presetId: request.creationMode === 'prompt' ? request.presetId : undefined,
+                initialPrompt: request.creationMode === 'prompt'
+                    ? request.initialPrompt
+                    : undefined,
+            });
         }
     };
     const handleCancelNewWorktree = () => {
@@ -296,7 +388,11 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
         setPendingWorktreeCreation(null);
         // Retry worktree creation with the resolved base branch
         // Set loading context before showing loading view
-        setLoadingContext({ copySessionData: creationData.copySessionData });
+        setLoadingContext({
+            copySessionData: creationData.copySessionData,
+            isPromptFlow: Boolean(creationData.presetId && creationData.initialPrompt),
+            stage: 'creating',
+        });
         setView('creating-worktree');
         setError(null);
         const result = await Effect.runPromise(Effect.either(worktreeService.createWorktreeEffect(creationData.path, creationData.branch, selectedRemoteRef, // Use the selected remote reference
@@ -308,8 +404,15 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
             setView('new-worktree');
         }
         else {
-            // Success - return to menu
-            handleReturnToMenu();
+            handleWorktreeCreationResult({ success: true }, {
+                path: creationData.path,
+                branch: creationData.branch,
+                baseBranch: selectedRemoteRef,
+                copySessionData: creationData.copySessionData,
+                copyClaudeDirectory: creationData.copyClaudeDirectory,
+                presetId: creationData.presetId,
+                initialPrompt: creationData.initialPrompt,
+            });
         }
     };
     const handleRemoteBranchSelectorCancel = () => {
@@ -400,9 +503,13 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
     }
     if (view === 'creating-worktree') {
         // Compose message based on loading context
-        const message = loadingContext.copySessionData
-            ? 'Creating worktree and copying session data...'
-            : 'Creating worktree...';
+        const message = loadingContext.isPromptFlow
+            ? loadingContext.stage === 'naming'
+                ? 'Generating branch name with Claude...'
+                : 'Creating worktree from generated branch name...'
+            : loadingContext.copySessionData
+                ? 'Creating worktree and copying session data...'
+                : 'Creating worktree...';
         return (_jsx(Box, { flexDirection: "column", children: _jsx(LoadingSpinner, { message: message, color: "cyan" }) }));
     }
     if (view === 'delete-worktree') {
@@ -441,9 +548,11 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
     if (view === 'creating-session-preset') {
         // Always display preset-specific message
         // Devcontainer operations take >5 seconds, so indicate extended duration
-        const message = devcontainerConfig
-            ? 'Creating session with preset (this may take a moment)...'
-            : 'Creating session with preset...';
+        const message = loadingContext.isPromptFlow
+            ? 'Creating session with preset and prompt...'
+            : devcontainerConfig
+                ? 'Creating session with preset (this may take a moment)...'
+                : 'Creating session with preset...';
         // Use yellow color for devcontainer, cyan for standard
         const color = devcontainerConfig ? 'yellow' : 'cyan';
         return (_jsx(Box, { flexDirection: "column", children: _jsx(LoadingSpinner, { message: message, color: color }) }));

package/dist/components/App.test.js

@@ -33,6 +33,9 @@ const configReaderMock = {
 const projectManagerMock = {
     addRecentProject: vi.fn(),
 };
+const worktreeNameGeneratorMock = {
+    generateBranchNameEffect: vi.fn(() => Effect.succeed('fix/trim-worktree-name')),
+};
 function createInkMock(label, onRender) {
     return async () => {
         const ReactActual = await vi.importActual('react');
@@ -64,11 +67,15 @@ vi.mock('../services/projectManager.js', () => ({
 vi.mock('../services/config/configReader.js', () => ({
     configReader: configReaderMock,
 }));
+vi.mock('../services/worktreeNameGenerator.js', () => ({
+    worktreeNameGenerator: worktreeNameGeneratorMock,
+}));
 vi.mock('../services/worktreeService.js', () => ({
     WorktreeService: vi.fn(function () {
         return {
             createWorktreeEffect: (...args) => createWorktreeEffectMock(...args),
             deleteWorktreeEffect: (...args) => deleteWorktreeEffectMock(...args),
+            getAllBranchesEffect: () => Effect.succeed([]),
         };
     }),
 }));
@@ -118,13 +125,20 @@ beforeEach(() => {
     sessionProps = undefined;
     createWorktreeEffectMock.mockReset();
     deleteWorktreeEffectMock.mockReset();
-    createWorktreeEffectMock.mockImplementation(() => Effect.succeed(undefined));
+    createWorktreeEffectMock.mockImplementation((path, branch) => Effect.succeed({
+        path,
+        branch,
+        isMainWorktree: false,
+        hasSession: false,
+    }));
     deleteWorktreeEffectMock.mockImplementation(() => Effect.succeed(undefined));
     sessionManagers.length = 0;
     getManagerForProjectMock.mockClear();
     configReaderMock.getSelectPresetOnStart.mockReset();
     configReaderMock.getSelectPresetOnStart.mockReturnValue(false);
     projectManagerMock.addRecentProject.mockReset();
+    worktreeNameGeneratorMock.generateBranchNameEffect.mockReset();
+    worktreeNameGeneratorMock.generateBranchNameEffect.mockImplementation(() => Effect.succeed('fix/trim-worktree-name'));
 });
 afterEach(() => {
     delete process.env[ENV_VARS.MULTI_PROJECT_ROOT];
@@ -153,7 +167,12 @@ describe('App component loading state machine', () => {
         let resolveWorktree;
         createWorktreeEffectMock.mockImplementation(() => Effect.tryPromise({
             try: () => new Promise(resolve => {
-                resolveWorktree = resolve;
+                resolveWorktree = () => resolve({
+                    path: '/tmp/test',
+                    branch: 'feature',
+                    isMainWorktree: false,
+                    hasSession: false,
+                });
             }),
             catch: (error) => error,
         }));
@@ -168,7 +187,14 @@ describe('App component loading state machine', () => {
         }));
         await waitForCondition(() => Boolean(newWorktreeProps));
         const newWorktree = newWorktreeProps;
-        const createPromise = Promise.resolve(newWorktree.onComplete('/tmp/test', 'feature', 'main', true, false));
+        const createPromise = Promise.resolve(newWorktree.onComplete({
+            creationMode: 'manual',
+            path: '/tmp/test',
+            branch: 'feature',
+            baseBranch: 'main',
+            copySessionData: true,
+            copyClaudeDirectory: false,
+        }));
         await flush();
         expect(lastFrame()).toContain('Creating worktree and copying session data...');
         resolveWorktree?.();
@@ -178,6 +204,69 @@ describe('App component loading state machine', () => {
         expect(lastFrame()).toContain('Menu View');
         unmount();
     });
+    it('auto-starts the prompt-first session with the created worktree path', async () => {
+        const { lastFrame, unmount } = render(_jsx(App, { version: "test" }));
+        await waitForCondition(() => Boolean(menuProps));
+        expect(sessionManagers).toHaveLength(1);
+        const sessionManager = sessionManagers[0];
+        const menu = menuProps;
+        await Promise.resolve(menu.onSelectWorktree({
+            path: '',
+            branch: '',
+            isMainWorktree: false,
+            hasSession: false,
+        }));
+        await waitForCondition(() => Boolean(newWorktreeProps));
+        await Promise.resolve(newWorktreeProps.onComplete({
+            creationMode: 'prompt',
+            path: '/tmp/project',
+            projectPath: '/tmp/project',
+            autoDirectoryPattern: '../{branch}',
+            baseBranch: 'main',
+            presetId: 'claude',
+            initialPrompt: 'trim worktree name output',
+            copySessionData: false,
+            copyClaudeDirectory: false,
+        }));
+        const createdPath = createWorktreeEffectMock.mock.calls[0]?.[0];
+        await waitForCondition(() => sessionManager.createSessionWithPresetEffect.mock.calls.length > 0, 200);
+        await waitForCondition(() => lastFrame()?.includes('Session View') ?? false);
+        expect(sessionManager.createSessionWithPresetEffect).toHaveBeenCalledWith(createdPath, 'claude', 'trim worktree name output');
+        expect(sessionProps?.session).toEqual(mockSession);
+        unmount();
+    });
+    it('uses the created worktree path when auto-starting a prompt-first session', async () => {
+        createWorktreeEffectMock.mockImplementation((_path, branch) => Effect.succeed({
+            path: '/tmp/resolved-worktree',
+            branch,
+            isMainWorktree: false,
+            hasSession: false,
+        }));
+        const { unmount } = render(_jsx(App, { version: "test" }));
+        await waitForCondition(() => Boolean(menuProps));
+        const sessionManager = sessionManagers[0];
+        await Promise.resolve(menuProps.onSelectWorktree({
+            path: '',
+            branch: '',
+            isMainWorktree: false,
+            hasSession: false,
+        }));
+        await waitForCondition(() => Boolean(newWorktreeProps));
+        await Promise.resolve(newWorktreeProps.onComplete({
+            creationMode: 'prompt',
+            path: '../relative-worktree',
+            projectPath: '/tmp/project',
+            autoDirectoryPattern: '../{branch}',
+            baseBranch: 'main',
+            presetId: 'claude',
+            initialPrompt: 'trim worktree name output',
+            copySessionData: false,
+            copyClaudeDirectory: false,
+        }));
+        await waitForCondition(() => sessionManager.createSessionWithPresetEffect.mock.calls.length > 0, 200);
+        expect(sessionManager.createSessionWithPresetEffect).toHaveBeenCalledWith('/tmp/resolved-worktree', 'claude', 'trim worktree name output');
+        unmount();
+    });
     it('displays branch deletion message while deleting worktrees', async () => {
         let resolveDelete;
         deleteWorktreeEffectMock.mockImplementation(() => Effect.tryPromise({

package/dist/components/Menu.recent-projects.test.js

@@ -132,12 +132,12 @@ describe('Menu - Recent Projects', () => {
         const { lastFrame, rerender } = render(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));
         // Force a rerender to ensure all effects have run
         rerender(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));
-        // Wait for Effect to execute
-        await new Promise(resolve => setTimeout(resolve, 100));
-        const output = lastFrame();
-        expect(output).toContain('─ Recent ─');
-        expect(output).toContain('Project 1');
-        expect(output).toContain('Project 2');
+        await vi.waitFor(() => {
+            const output = lastFrame();
+            expect(output).toContain('─ Recent ─');
+            expect(output).toContain('Project 1');
+            expect(output).toContain('Project 2');
+        });
     });
     it('should not show recent projects section when no recent projects', () => {
         vi.mocked(projectManager.getRecentProjects).mockReturnValue([]);
@@ -164,12 +164,12 @@ describe('Menu - Recent Projects', () => {
         });
         vi.spyOn(SessionManager, 'formatSessionCounts').mockReturnValue('');
         const { lastFrame } = render(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));
-        // Wait for Effect to execute
-        await new Promise(resolve => setTimeout(resolve, 100));
-        const output = lastFrame();
-        expect(output).toContain('─ Recent ─');
-        expect(output).toContain('Project 0');
-        expect(output).toContain('Project 4');
+        await vi.waitFor(() => {
+            const output = lastFrame();
+            expect(output).toContain('─ Recent ─');
+            expect(output).toContain('Project 0');
+            expect(output).toContain('Project 4');
+        });
     });
     it('should filter out current project from recent projects', async () => {
         // Setup the initial recent projects
@@ -186,13 +186,13 @@ describe('Menu - Recent Projects', () => {
         const { lastFrame, rerender } = render(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: worktreeServiceWithGitRoot, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));
         // Force a rerender to ensure all effects have run
         rerender(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: worktreeServiceWithGitRoot, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));
-        // Wait for the state to update and component to re-render
-        await new Promise(resolve => setTimeout(resolve, 50));
-        const output = lastFrame();
-        expect(output).toContain('─ Recent ─');
-        expect(output).not.toContain('Current Project');
-        expect(output).toContain('Project 1');
-        expect(output).toContain('Project 2');
+        await vi.waitFor(() => {
+            const output = lastFrame();
+            expect(output).toContain('─ Recent ─');
+            expect(output).not.toContain('Current Project');
+            expect(output).toContain('Project 1');
+            expect(output).toContain('Project 2');
+        });
     });
     it('should hide recent projects section when all projects are filtered out', () => {
         vi.mocked(projectManager.getRecentProjects).mockReturnValue([

package/dist/components/NewWorktree.d.ts

@@ -1,8 +1,27 @@
 import React from 'react';
 interface NewWorktreeProps {
     projectPath?: string;
-    onComplete: (path: string, branch: string, baseBranch: string, copySessionData: boolean, copyClaudeDirectory: boolean) => void;
+    onComplete: (request: NewWorktreeRequest) => void;
     onCancel: () => void;
 }
+export type NewWorktreeRequest = {
+    creationMode: 'manual';
+    path: string;
+    branch: string;
+    baseBranch: string;
+    copySessionData: boolean;
+    copyClaudeDirectory: boolean;
+} | {
+    creationMode: 'prompt';
+    path: string;
+    projectPath: string;
+    autoDirectoryPattern?: string;
+    baseBranch: string;
+    presetId: string;
+    initialPrompt: string;
+    copySessionData: boolean;
+    copyClaudeDirectory: boolean;
+    branch?: never;
+};
 declare const NewWorktree: React.FC<NewWorktreeProps>;
 export default NewWorktree;