cleanupWorktree method

Future<void> cleanupWorktree()

Cleans up the worktree, removing it and its branch.

Implementation

Future<void> cleanupWorktree() async {
  final session = currentSession.value;
  if (session == null) return;

  try {
    Directory.current = Directory(session.originalCwd);

    if (session.hookBased) {
      if (onExecuteWorktreeRemoveHook != null) {
        final hookRan = await onExecuteWorktreeRemoveHook!(
          session.worktreePath,
        );
        if (hookRan) {
          _logForDebugging(
            'Removed hook-based worktree at: ${session.worktreePath}',
          );
        } else {
          _logForDebugging(
            'No WorktreeRemove hook configured, hook-based worktree left at: '
            '${session.worktreePath}',
            level: 'warn',
          );
        }
      }
    } else {
      final removeResult = await _execGit([
        'worktree',
        'remove',
        '--force',
        session.worktreePath,
      ], cwd: session.originalCwd);

      if (removeResult.code != 0) {
        _logForDebugging(
          'Failed to remove linked worktree: ${removeResult.stderr}',
          level: 'error',
        );
      } else {
        _logForDebugging(
          'Removed linked worktree at: ${session.worktreePath}',
        );
      }
    }

    currentSession.value = null;
    onSaveProjectConfig?.call(null);

    // Delete the temporary worktree branch (git-based only)
    if (!session.hookBased && session.worktreeBranch != null) {
      await Future.delayed(const Duration(milliseconds: 100));

      final deleteResult = await _execGit([
        'branch',
        '-D',
        session.worktreeBranch!,
      ], cwd: session.originalCwd);

      if (deleteResult.code != 0) {
        _logForDebugging(
          'Could not delete worktree branch: ${deleteResult.stderr}',
          level: 'error',
        );
      } else {
        _logForDebugging(
          'Deleted worktree branch: ${session.worktreeBranch}',
        );
      }
    }

    _logForDebugging('Linked worktree cleaned up completely');
  } catch (e) {
    _logForDebugging('Error cleaning up worktree: $e', level: 'error');
  }
}