ccmanager 1.4.5 → 2.1.0

package/dist/services/projectManager.test.js

@@ -0,0 +1,342 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { ProjectManager } from './projectManager.js';
+import { ENV_VARS } from '../constants/env.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+// Mock fs module
+vi.mock('fs');
+vi.mock('os');
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const mockFs = fs;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const mockOs = os;
+describe('ProjectManager', () => {
+    let projectManager;
+    const mockProjectsDir = '/home/user/projects';
+    const mockConfigDir = '/home/user/.config/ccmanager';
+    const mockRecentProjectsPath = '/home/user/.config/ccmanager/recent-projects.json';
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Reset environment variables
+        delete process.env[ENV_VARS.MULTI_PROJECT_ROOT];
+        // Mock os.homedir
+        mockOs.homedir.mockReturnValue('/home/user');
+        // Mock fs methods for config directory
+        mockFs.existsSync.mockImplementation((path) => {
+            if (path === mockConfigDir)
+                return true;
+            if (path === mockRecentProjectsPath)
+                return false;
+            return false;
+        });
+        mockFs.mkdirSync.mockImplementation(() => { });
+        mockFs.readFileSync.mockImplementation(() => '[]');
+        mockFs.writeFileSync.mockImplementation(() => { });
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('initialization', () => {
+        it('should initialize in normal mode when no multi-project root is set', () => {
+            projectManager = new ProjectManager();
+            expect(projectManager.currentMode).toBe('normal');
+            expect(projectManager.currentProject).toBeUndefined();
+            expect(projectManager.projects).toEqual([]);
+        });
+        it('should initialize in multi-project mode when multi-project root is set', () => {
+            process.env[ENV_VARS.MULTI_PROJECT_ROOT] = mockProjectsDir;
+            projectManager = new ProjectManager();
+            expect(projectManager.currentMode).toBe('multi-project');
+        });
+    });
+    describe('project discovery', () => {
+        beforeEach(() => {
+            process.env[ENV_VARS.MULTI_PROJECT_ROOT] = mockProjectsDir;
+            projectManager = new ProjectManager();
+        });
+        it('should discover git projects in the projects directory', async () => {
+            // Mock file system for project discovery
+            mockFs.promises = {
+                access: vi.fn().mockResolvedValue(undefined),
+                readdir: vi.fn().mockImplementation((dir) => {
+                    if (dir === mockProjectsDir) {
+                        return Promise.resolve([
+                            { name: 'project1', isDirectory: () => true },
+                            { name: 'project2', isDirectory: () => true },
+                            { name: 'not-a-project.txt', isDirectory: () => false },
+                        ]);
+                    }
+                    return Promise.resolve([]);
+                }),
+                stat: vi.fn().mockImplementation((path) => {
+                    if (path.endsWith('.git')) {
+                        return Promise.resolve({
+                            isDirectory: () => true,
+                            isFile: () => false,
+                        });
+                    }
+                    throw new Error('Not found');
+                }),
+            };
+            await projectManager.refreshProjects();
+            expect(projectManager.projects).toHaveLength(2);
+            expect(projectManager.projects[0]).toMatchObject({
+                name: 'project1',
+                path: path.join(mockProjectsDir, 'project1'),
+                isValid: true,
+            });
+            expect(projectManager.projects[1]).toMatchObject({
+                name: 'project2',
+                path: path.join(mockProjectsDir, 'project2'),
+                isValid: true,
+            });
+        });
+        it('should handle projects directory not existing', async () => {
+            mockFs.promises = {
+                access: vi.fn().mockRejectedValue({ code: 'ENOENT' }),
+            };
+            await expect(projectManager.refreshProjects()).rejects.toThrow(`Projects directory does not exist: ${mockProjectsDir}`);
+        });
+    });
+    describe('recent projects', () => {
+        beforeEach(() => {
+            projectManager = new ProjectManager();
+        });
+        it('should get recent projects with default limit', () => {
+            const mockRecentProjects = [
+                { path: '/path/to/project1', name: 'project1', lastAccessed: Date.now() },
+                {
+                    path: '/path/to/project2',
+                    name: 'project2',
+                    lastAccessed: Date.now() - 1000,
+                },
+                {
+                    path: '/path/to/project3',
+                    name: 'project3',
+                    lastAccessed: Date.now() - 2000,
+                },
+                {
+                    path: '/path/to/project4',
+                    name: 'project4',
+                    lastAccessed: Date.now() - 3000,
+                },
+                {
+                    path: '/path/to/project5',
+                    name: 'project5',
+                    lastAccessed: Date.now() - 4000,
+                },
+                {
+                    path: '/path/to/project6',
+                    name: 'project6',
+                    lastAccessed: Date.now() - 5000,
+                },
+            ];
+            mockFs.readFileSync.mockReturnValue(JSON.stringify(mockRecentProjects));
+            mockFs.existsSync.mockReturnValue(true);
+            // Re-create to load recent projects
+            projectManager = new ProjectManager();
+            const recent = projectManager.getRecentProjects();
+            expect(recent).toHaveLength(5); // Default limit
+            expect(recent[0]?.name).toBe('project1');
+            expect(recent[4]?.name).toBe('project5');
+        });
+        it('should get recent projects with custom limit', () => {
+            const mockRecentProjects = [
+                { path: '/path/to/project1', name: 'project1', lastAccessed: Date.now() },
+                {
+                    path: '/path/to/project2',
+                    name: 'project2',
+                    lastAccessed: Date.now() - 1000,
+                },
+                {
+                    path: '/path/to/project3',
+                    name: 'project3',
+                    lastAccessed: Date.now() - 2000,
+                },
+            ];
+            mockFs.readFileSync.mockReturnValue(JSON.stringify(mockRecentProjects));
+            mockFs.existsSync.mockReturnValue(true);
+            projectManager = new ProjectManager();
+            const recent = projectManager.getRecentProjects(2);
+            expect(recent).toHaveLength(2);
+        });
+        it('should add a recent project', () => {
+            const project = {
+                name: 'test-project',
+                path: '/path/to/test-project',
+                relativePath: 'test-project',
+                isValid: true,
+            };
+            projectManager.addRecentProject(project);
+            expect(mockFs.writeFileSync).toHaveBeenCalled();
+            const writtenData = JSON.parse(mockFs.writeFileSync.mock.calls[0][1]);
+            expect(writtenData).toHaveLength(1);
+            expect(writtenData[0]).toMatchObject({
+                path: project.path,
+                name: project.name,
+            });
+        });
+        it('should update existing recent project', () => {
+            const existingProject = {
+                path: '/path/to/project1',
+                name: 'project1',
+                lastAccessed: Date.now() - 10000,
+            };
+            mockFs.readFileSync.mockReturnValue(JSON.stringify([existingProject]));
+            mockFs.existsSync.mockReturnValue(true);
+            projectManager = new ProjectManager();
+            const updatedProject = {
+                name: 'project1',
+                path: '/path/to/project1',
+                relativePath: 'project1',
+                isValid: true,
+            };
+            projectManager.addRecentProject(updatedProject);
+            const writtenData = JSON.parse(mockFs.writeFileSync.mock.calls[0][1]);
+            expect(writtenData).toHaveLength(1);
+            expect(writtenData[0].lastAccessed).toBeGreaterThan(existingProject.lastAccessed);
+        });
+        it('should not add EXIT_APPLICATION to recent projects', () => {
+            const exitProject = {
+                name: 'Exit',
+                path: 'EXIT_APPLICATION',
+                relativePath: '',
+                isValid: true,
+            };
+            projectManager.addRecentProject(exitProject);
+            expect(mockFs.writeFileSync).not.toHaveBeenCalled();
+        });
+        it('should clear recent projects', () => {
+            projectManager.clearRecentProjects();
+            expect(mockFs.writeFileSync).toHaveBeenCalledWith(mockRecentProjectsPath, JSON.stringify([], null, 2));
+        });
+    });
+    describe('mode management', () => {
+        beforeEach(() => {
+            process.env[ENV_VARS.MULTI_PROJECT_ROOT] = mockProjectsDir;
+            projectManager = new ProjectManager();
+        });
+        it('should set mode correctly', () => {
+            projectManager.setMode('normal');
+            expect(projectManager.currentMode).toBe('normal');
+            projectManager.setMode('multi-project');
+            expect(projectManager.currentMode).toBe('multi-project');
+        });
+        it('should clear current project when switching to normal mode', () => {
+            const project = {
+                name: 'test',
+                path: '/test',
+                relativePath: 'test',
+                isValid: true,
+            };
+            projectManager.selectProject(project);
+            expect(projectManager.currentProject).toBe(project);
+            projectManager.setMode('normal');
+            expect(projectManager.currentProject).toBeUndefined();
+        });
+    });
+    describe('project selection', () => {
+        beforeEach(() => {
+            projectManager = new ProjectManager();
+        });
+        it('should select a project', () => {
+            const project = {
+                name: 'test',
+                path: '/test',
+                relativePath: 'test',
+                isValid: true,
+            };
+            projectManager.selectProject(project);
+            expect(projectManager.currentProject).toBe(project);
+        });
+    });
+    describe('worktree service management', () => {
+        beforeEach(() => {
+            projectManager = new ProjectManager();
+        });
+        it('should get worktree service for current project', () => {
+            const project = {
+                name: 'test',
+                path: '/test/project',
+                relativePath: 'test',
+                isValid: true,
+            };
+            projectManager.selectProject(project);
+            const service = projectManager.getWorktreeService();
+            expect(service).toBeDefined();
+            expect(service.getGitRootPath()).toBe('/test/project');
+        });
+        it('should cache worktree services', () => {
+            const service1 = projectManager.getWorktreeService('/test/path1');
+            const service2 = projectManager.getWorktreeService('/test/path1');
+            expect(service1).toBe(service2);
+        });
+        it('should clear worktree service cache', () => {
+            projectManager.getWorktreeService('/test/path1');
+            projectManager.getWorktreeService('/test/path2');
+            projectManager.clearWorktreeServiceCache('/test/path1');
+            const cachedServices = projectManager.getCachedServices();
+            expect(cachedServices.size).toBe(1);
+            expect(cachedServices.has('/test/path2')).toBe(true);
+        });
+        it('should clear all worktree service cache', () => {
+            projectManager.getWorktreeService('/test/path1');
+            projectManager.getWorktreeService('/test/path2');
+            projectManager.clearWorktreeServiceCache();
+            const cachedServices = projectManager.getCachedServices();
+            expect(cachedServices.size).toBe(0);
+        });
+    });
+    describe('helper methods', () => {
+        beforeEach(() => {
+            projectManager = new ProjectManager();
+        });
+        it('should check if multi-project is enabled', () => {
+            expect(projectManager.isMultiProjectEnabled()).toBe(false);
+            process.env[ENV_VARS.MULTI_PROJECT_ROOT] = mockProjectsDir;
+            projectManager = new ProjectManager();
+            expect(projectManager.isMultiProjectEnabled()).toBe(true);
+        });
+        it('should get projects directory', () => {
+            expect(projectManager.getProjectsDir()).toBeUndefined();
+            process.env[ENV_VARS.MULTI_PROJECT_ROOT] = mockProjectsDir;
+            projectManager = new ProjectManager();
+            expect(projectManager.getProjectsDir()).toBe(mockProjectsDir);
+        });
+        it('should get current project path', () => {
+            const cwd = process.cwd();
+            expect(projectManager.getCurrentProjectPath()).toBe(cwd);
+            const project = {
+                name: 'test',
+                path: '/test/project',
+                relativePath: 'test',
+                isValid: true,
+            };
+            projectManager.selectProject(project);
+            expect(projectManager.getCurrentProjectPath()).toBe('/test/project');
+        });
+    });
+    describe('project validation', () => {
+        beforeEach(() => {
+            projectManager = new ProjectManager();
+        });
+        it('should validate a git repository', async () => {
+            mockFs.promises = {
+                stat: vi.fn().mockResolvedValue({
+                    isDirectory: () => true,
+                    isFile: () => false,
+                }),
+            };
+            const isValid = await projectManager.validateGitRepository('/test/repo');
+            expect(isValid).toBe(true);
+        });
+        it('should invalidate non-git repository', async () => {
+            mockFs.promises = {
+                stat: vi.fn().mockRejectedValue(new Error('Not found')),
+            };
+            const isValid = await projectManager.validateGitRepository('/test/not-repo');
+            expect(isValid).toBe(false);
+        });
+    });
+});

package/dist/services/sessionManager.d.ts

@@ -1,5 +1,11 @@
 import { Session, SessionManager as ISessionManager, SessionState, DevcontainerConfig } from '../types/index.js';
 import { EventEmitter } from 'events';
+export interface SessionCounts {
+    idle: number;
+    busy: number;
+    waiting_input: number;
+    total: number;
+}
 export declare class SessionManager extends EventEmitter implements ISessionManager {
     sessions: Map<string, Session>;
     private waitingWithBottomBorder;
@@ -29,4 +35,6 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private executeStatusHook;
     createSessionWithDevcontainer(worktreePath: string, devcontainerConfig: DevcontainerConfig, presetId?: string): Promise<Session>;
     destroy(): void;
+    static getSessionCounts(sessions: Session[]): SessionCounts;
+    static formatSessionCounts(counts: SessionCounts): string;
 }

package/dist/services/sessionManager.js

@@ -330,4 +330,42 @@ export class SessionManager extends EventEmitter {
             this.destroySession(worktreePath);
         }
     }
+    static getSessionCounts(sessions) {
+        const counts = {
+            idle: 0,
+            busy: 0,
+            waiting_input: 0,
+            total: sessions.length,
+        };
+        sessions.forEach(session => {
+            switch (session.state) {
+                case 'idle':
+                    counts.idle++;
+                    break;
+                case 'busy':
+                    counts.busy++;
+                    break;
+                case 'waiting_input':
+                    counts.waiting_input++;
+                    break;
+            }
+        });
+        return counts;
+    }
+    static formatSessionCounts(counts) {
+        if (counts.total === 0) {
+            return '';
+        }
+        const parts = [];
+        if (counts.idle > 0) {
+            parts.push(`${counts.idle} Idle`);
+        }
+        if (counts.busy > 0) {
+            parts.push(`${counts.busy} Busy`);
+        }
+        if (counts.waiting_input > 0) {
+            parts.push(`${counts.waiting_input} Waiting`);
+        }
+        return parts.length > 0 ? ` (${parts.join(' / ')})` : '';
+    }
 }

package/dist/services/sessionManager.test.js

@@ -694,4 +694,83 @@ describe('SessionManager', () => {
             expect(session.isPrimaryCommand).toBe(false);
         });
     });
+    describe('static methods', () => {
+        describe('getSessionCounts', () => {
+            it('should count sessions by state', () => {
+                const sessions = [
+                    { id: '1', state: 'idle' },
+                    { id: '2', state: 'busy' },
+                    { id: '3', state: 'busy' },
+                    { id: '4', state: 'waiting_input' },
+                    { id: '5', state: 'idle' },
+                ];
+                const counts = SessionManager.getSessionCounts(sessions);
+                expect(counts.idle).toBe(2);
+                expect(counts.busy).toBe(2);
+                expect(counts.waiting_input).toBe(1);
+                expect(counts.total).toBe(5);
+            });
+            it('should handle empty sessions array', () => {
+                const counts = SessionManager.getSessionCounts([]);
+                expect(counts.idle).toBe(0);
+                expect(counts.busy).toBe(0);
+                expect(counts.waiting_input).toBe(0);
+                expect(counts.total).toBe(0);
+            });
+            it('should handle sessions with single state', () => {
+                const sessions = [
+                    { id: '1', state: 'busy' },
+                    { id: '2', state: 'busy' },
+                    { id: '3', state: 'busy' },
+                ];
+                const counts = SessionManager.getSessionCounts(sessions);
+                expect(counts.idle).toBe(0);
+                expect(counts.busy).toBe(3);
+                expect(counts.waiting_input).toBe(0);
+                expect(counts.total).toBe(3);
+            });
+        });
+        describe('formatSessionCounts', () => {
+            it('should format counts with all states', () => {
+                const counts = {
+                    idle: 1,
+                    busy: 2,
+                    waiting_input: 1,
+                    total: 4,
+                };
+                const formatted = SessionManager.formatSessionCounts(counts);
+                expect(formatted).toBe(' (1 Idle / 2 Busy / 1 Waiting)');
+            });
+            it('should format counts with some states', () => {
+                const counts = {
+                    idle: 2,
+                    busy: 0,
+                    waiting_input: 1,
+                    total: 3,
+                };
+                const formatted = SessionManager.formatSessionCounts(counts);
+                expect(formatted).toBe(' (2 Idle / 1 Waiting)');
+            });
+            it('should format counts with single state', () => {
+                const counts = {
+                    idle: 0,
+                    busy: 3,
+                    waiting_input: 0,
+                    total: 3,
+                };
+                const formatted = SessionManager.formatSessionCounts(counts);
+                expect(formatted).toBe(' (3 Busy)');
+            });
+            it('should return empty string for zero sessions', () => {
+                const counts = {
+                    idle: 0,
+                    busy: 0,
+                    waiting_input: 0,
+                    total: 0,
+                };
+                const formatted = SessionManager.formatSessionCounts(counts);
+                expect(formatted).toBe('');
+            });
+        });
+    });
 });

package/dist/services/worktreeService.d.ts

@@ -7,6 +7,7 @@ export declare class WorktreeService {
     getWorktrees(): Worktree[];
     private getCurrentBranch;
     isGitRepository(): boolean;
+    getGitRootPath(): string;
     getDefaultBranch(): string;
     getAllBranches(): string[];
     createWorktree(worktreePath: string, branch: string, baseBranch: string, copySessionData?: boolean, copyClaudeDirectory?: boolean): {

package/dist/services/worktreeService.js

@@ -18,7 +18,7 @@ export class WorktreeService {
             writable: true,
             value: void 0
         });
-        this.rootPath = rootPath || process.cwd();
+        this.rootPath = path.resolve(rootPath || process.cwd());
         // Get the actual git repository root for worktree operations
         this.gitRootPath = this.getGitRepositoryRoot();
     }
@@ -29,12 +29,24 @@ export class WorktreeService {
                 cwd: this.rootPath,
                 encoding: 'utf8',
             }).trim();
-            // The parent of .git is the actual repository root
-            return path.dirname(gitCommonDir);
+            // Make sure we have an absolute path
+            const absoluteGitCommonDir = path.isAbsolute(gitCommonDir)
+                ? gitCommonDir
+                : path.resolve(this.rootPath, gitCommonDir);
+            // Handle worktree paths: if path contains .git/worktrees, we need to find the real .git parent
+            if (absoluteGitCommonDir.includes('.git/worktrees')) {
+                // Extract the path up to and including .git
+                const gitIndex = absoluteGitCommonDir.indexOf('.git');
+                const gitPath = absoluteGitCommonDir.substring(0, gitIndex + 4);
+                // The parent of .git is the actual repository root
+                return path.dirname(gitPath);
+            }
+            // For regular .git directories, the parent is the repository root
+            return path.dirname(absoluteGitCommonDir);
         }
         catch {
-            // Fallback to current directory if command fails
-            return this.rootPath;
+            // Fallback to current directory if command fails - ensure it's absolute
+            return path.resolve(this.rootPath);
         }
     }
     getWorktrees() {
@@ -114,6 +126,9 @@ export class WorktreeService {
     isGitRepository() {
         return existsSync(path.join(this.rootPath, '.git'));
     }
+    getGitRootPath() {
+        return this.gitRootPath;
+    }
     getDefaultBranch() {
         try {
             // Try to get the default branch from origin

package/dist/services/worktreeService.test.js

@@ -31,6 +31,78 @@ describe('WorktreeService', () => {
         });
         service = new WorktreeService('/fake/path');
     });
+    describe('getGitRootPath', () => {
+        it('should always return an absolute path when git command returns absolute path', () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string' &&
+                    cmd === 'git rev-parse --git-common-dir') {
+                    return '/absolute/repo/.git\n';
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const service = new WorktreeService('/some/path');
+            const result = service.getGitRootPath();
+            expect(result).toBe('/absolute/repo');
+            expect(result.startsWith('/')).toBe(true);
+        });
+        it('should convert relative path to absolute path', () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string' &&
+                    cmd === 'git rev-parse --git-common-dir') {
+                    return '.git\n';
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const service = new WorktreeService('/work/project');
+            const result = service.getGitRootPath();
+            // Should resolve relative .git to absolute path
+            expect(result).toBe('/work/project');
+            expect(result.startsWith('/')).toBe(true);
+        });
+        it('should handle relative paths with subdirectories', () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string' &&
+                    cmd === 'git rev-parse --git-common-dir') {
+                    return '../.git\n';
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const service = new WorktreeService('/work/project/subdir');
+            const result = service.getGitRootPath();
+            // Should resolve relative ../.git to absolute path
+            expect(result).toBe('/work/project');
+            expect(result.startsWith('/')).toBe(true);
+        });
+        it('should return absolute path on git command failure', () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string' &&
+                    cmd === 'git rev-parse --git-common-dir') {
+                    throw new Error('Not a git repository');
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const service = new WorktreeService('relative/path');
+            const result = service.getGitRootPath();
+            // Should convert relative path to absolute path
+            expect(result.startsWith('/')).toBe(true);
+            expect(result.endsWith('relative/path')).toBe(true);
+        });
+        it('should handle worktree paths correctly', () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string' &&
+                    cmd === 'git rev-parse --git-common-dir') {
+                    // Worktrees often return paths like: /path/to/main/.git/worktrees/feature
+                    return '/main/repo/.git/worktrees/feature\n';
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const service = new WorktreeService('/main/repo/feature-worktree');
+            const result = service.getGitRootPath();
+            // Should get the parent of .git directory
+            expect(result).toBe('/main/repo');
+            expect(result.startsWith('/')).toBe(true);
+        });
+    });
     describe('getDefaultBranch', () => {
         it('should return default branch from origin', () => {
             mockedExecSync.mockImplementation((cmd, _options) => {

package/dist/types/index.d.ts

@@ -88,3 +88,58 @@ export interface ConfigurationData {
     command?: CommandConfig;
     commandPresets?: CommandPresetsConfig;
 }
+export interface GitProject {
+    name: string;
+    path: string;
+    relativePath: string;
+    isValid: boolean;
+    error?: string;
+}
+export interface MultiProjectConfig {
+    enabled: boolean;
+    projectsDir: string;
+    rootMarker?: string;
+}
+export type MenuMode = 'normal' | 'multi-project';
+export interface IMultiProjectService {
+    discoverProjects(projectsDir: string): Promise<GitProject[]>;
+    validateGitRepository(path: string): Promise<boolean>;
+}
+export interface RecentProject {
+    path: string;
+    name: string;
+    lastAccessed: number;
+}
+export interface IProjectManager {
+    currentMode: MenuMode;
+    currentProject?: GitProject;
+    projects: GitProject[];
+    setMode(mode: MenuMode): void;
+    selectProject(project: GitProject): void;
+    getWorktreeService(projectPath?: string): IWorktreeService;
+    refreshProjects(): Promise<void>;
+    getRecentProjects(limit?: number): RecentProject[];
+    addRecentProject(project: GitProject): void;
+    clearRecentProjects(): void;
+    validateGitRepository(path: string): Promise<boolean>;
+}
+export interface IWorktreeService {
+    getWorktrees(): Worktree[];
+    getGitRootPath(): string;
+    createWorktree(worktreePath: string, branch: string, baseBranch: string, copySessionData?: boolean, copyClaudeDirectory?: boolean): {
+        success: boolean;
+        error?: string;
+    };
+    deleteWorktree(worktreePath: string, options?: {
+        deleteBranch?: boolean;
+    }): {
+        success: boolean;
+        error?: string;
+    };
+    mergeWorktree(worktreePath: string, targetBranch?: string): {
+        success: boolean;
+        mergedBranch?: string;
+        error?: string;
+        deletedWorktree?: boolean;
+    };
+}