rails-worktrees 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46ec0bdd9361eabe4925e37760bcd5d050c8f71072ec93cfdb427e244186ea8e
-  data.tar.gz: 965a2ea5c6d454739f833cf0a534a4b195903531d159e2fb25f5eff9bb71083c
+  metadata.gz: 46dd1369d93b3281d8182a90812164a1a245ff778b5af05306908989563e264e
+  data.tar.gz: 0d7e33ae49a56ea819e3a07ebfde966e1b1c18677af8c406bd15e93628ba8aff
 SHA512:
-  metadata.gz: fa02fa0f6786fb3865326f8cef1e4beb804a25411cc7b5d15676236424b23a5cd4e5b55bd21550f1b1e3f422384f1c06662ff05b9d40e291e931b1bd09775af2
-  data.tar.gz: 43269ef67990a1a4986f407a96696b9b01faabf8a64930e676c3c505a214d38b228ba3dae5e9ffa76fc74dc59d96bbdad3eafceb42c99236c64a23954fbefced
+  metadata.gz: 3d9e25b8d52ec84eb983d5b5ba28679394396232f61b8e9b626cf8a8f464b49e53d9f1898d0591bcd78e66620fa2b59869b1c781ed03b7a8a5f176f973a2ebbb
+  data.tar.gz: 795403173d6b6c8c375119b7427bebc620cc73deb9402a8c1c6aa25c863b703af882b4e4b01dd9bdbd123696f1949a1e00f830a92a227e93ddff3e09a1c763ee

data/.release-please-manifest.json

@@ -1 +1 @@
-{".":"0.3.0"}
+{".":"0.4.0"}

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.4.0](https://github.com/asjer/rails-worktrees/compare/v0.3.0...v0.4.0) (2026-03-30)
+
+
+### Features
+
+* **delete:** add `bin/wt remove` command to delete worktrees and local branches ([5905723](https://github.com/asjer/rails-worktrees/commit/5905723712e3ca11fd6614633e68855e33bb50e3))
+
 ## [0.3.0](https://github.com/asjer/rails-worktrees/compare/v0.2.2...v0.3.0) (2026-03-30)
 
 

data/README.md

@@ -42,6 +42,10 @@ bin/wt                          # auto-pick a name from bundled *.txt lists
 bin/wt my-feature               # use an explicit worktree name
 bin/wt --dry-run my-feature     # preview the full setup without changing anything
 bin/wt --print-env my-feature   # preview DEV_PORT and WORKTREE_DATABASE_SUFFIX
+bin/wt remove my-feature        # remove a worktree and delete its local branch
+bin/wt delete my-feature        # alias for `bin/wt remove`
+bin/wt remove --force my-feature # also delete an unmerged local branch
+bin/wt prune                    # remove merged worktrees created by wt
 
 bin/ob                          # open http://localhost:$DEV_PORT/
 bin/ob contact                  # open http://localhost:$DEV_PORT/contact
@@ -55,7 +59,8 @@ bin/ob --print-url '?from=nav'  # print the resolved URL without opening a brows
 |------|-------------|
 | `-h`, `--help` | Show the help message |
 | `-v`, `--version` | Show the script version |
-| `--dry-run [name]` | Preview the full worktree setup without changing anything |
+| `--dry-run [name]` | Preview worktree creation or cleanup without changing anything |
+| `--force` | Force branch deletion for `bin/wt remove` / `bin/wt delete` |
 | `--env`, `--print-env <name>` | Preview `DEV_PORT` and `WORKTREE_DATABASE_SUFFIX` |
 
 ### Default behavior
@@ -80,6 +85,33 @@ workspace/
 
 `WT_WORKSPACES_ROOT` or `config.workspace_root` overrides the destination root and uses the layout `<root>/<project>/<name>`.
 
+### Cleanup commands
+
+`bin/wt` also supports cleanup commands for worktrees it manages:
+
+- `bin/wt remove <name>` — remove the named worktree and delete its local branch
+- `bin/wt delete <name>` — alias for `bin/wt remove <name>`
+- `bin/wt prune` — remove merged worktrees created by `bin/wt` in bulk
+
+`bin/wt remove` and `bin/wt prune` can be run from the main checkout or any sibling worktree in the same repository family.
+
+`bin/wt remove` refuses to remove the worktree you're currently in, and by default only deletes a local branch after confirming it is already merged into `origin`'s default branch. Use `bin/wt remove --force <name>` when you intentionally want to delete an unmerged local branch too.
+
+`bin/wt prune` only targets linked worktrees created by `bin/wt` whose local branches are already merged into `origin`'s default branch. It skips the main checkout, skips the checkout you're currently in, and asks for confirmation before deleting the batch.
+
+If you want to preview a single removal first, use `--dry-run` with `bin/wt remove`:
+
+```bash
+bin/wt remove --dry-run feature-auth
+```
+
+If you want to see what `bin/wt prune` would clean up before saying yes, use `--dry-run`:
+
+```bash
+bin/wt prune --dry-run
+```
+
+
 ### Interactive prompts
 
 `bin/wt` handles several edge cases interactively:
@@ -88,6 +120,7 @@ workspace/
 - **Branch already exists on origin** — asks whether to create a local tracking worktree
 - **Target directory already exists with matching branch** — asks whether to reuse it
 - **Target directory already exists with a different branch** — asks whether to remove and recreate it
+- **Prune found merged worktrees created by `wt`** — asks whether to delete the batch
 - **Retired bundled name used explicitly** — rejects it and suggests running `wt` with no argument
 
 ### Name validation
@@ -197,7 +230,7 @@ This smoke test:
 - installs `rails-worktrees` from the current checkout path
 - runs `bin/rails generate worktrees:install --yolo`
 - verifies `bin/wt`, `bin/ob`, the generated initializer, that `--yolo` skips the Procfile example, yolo updates to `Procfile.dev`, `config/puma.rb`, and `mise.toml`, `config/database.yml` patching, and worktree `.env` bootstrapping
-- creates a temporary bare `origin` and confirms `bin/wt smoke-branch` creates a real worktree
+- creates a temporary bare `origin`, confirms `bin/wt smoke-branch` creates a real worktree, and confirms `bin/wt remove smoke-branch` can remove that merged worktree from a sibling worktree checkout
 
 By default, the script cleans up all temp directories after the run. Set `KEEP_SMOKE_TEST_ARTIFACTS=1` to keep them around for debugging, or set `RAILS_WORKTREES_SMOKE_RAILS_VERSION` to try a different compatible Rails version.
 

data/lib/rails/worktrees/command/git_operations.rb

@@ -1,9 +1,11 @@
 require 'open3'
+require 'fileutils'
 
 module Rails
   module Worktrees
     class Command
       # Shell-level git helpers, branch/worktree queries, and worktree creation.
+      # rubocop:disable Metrics/ModuleLength
       module GitOperations
         private
 
@@ -40,14 +42,18 @@ module Rails
           worktree_branch_checked_out?(branch_name, worktree_list_output)
         end
 
+        def current_checkout_branch
+          git_capture('branch', '--show-current', allow_failure: true).strip
+        end
+
         def registered_worktree_path?(target_dir)
           normalized_target = canonical_path(target_dir)
 
-          worktree_list_output.each_line.any? do |line|
-            next unless line.start_with?('worktree ')
+          worktree_entries.any? { |entry| entry[:path] == normalized_target }
+        end
 
-            canonical_path(line.delete_prefix('worktree ').strip) == normalized_target
-          end
+        def worktree_entries_for_branch(branch_name)
+          worktree_entries.select { |entry| entry[:branch_name] == branch_name }
         end
 
         def worktree_branch_checked_out?(branch_name, output)
@@ -59,11 +65,38 @@ module Rails
 
         def worktree_list_output = git_capture('worktree', 'list', '--porcelain')
 
+        def worktree_entries
+          worktree_list_output.split("\n\n").filter_map do |block|
+            entry = parse_worktree_entry(block)
+            entry[:path] ? entry : nil
+          end
+        end
+
+        def parse_worktree_entry(block)
+          entry = { branch_name: nil }
+
+          block.each_line(chomp: true) do |line|
+            case line
+            when /\Aworktree /
+              entry[:path] = canonical_path(line.delete_prefix('worktree '))
+            when %r{\Abranch refs/heads/}
+              entry[:branch_name] = line.delete_prefix('branch refs/heads/')
+            end
+          end
+
+          entry
+        end
+
         def canonical_path(path)
           File.realpath(path)
         rescue Errno::ENOENT then File.expand_path(path)
         end
 
+        def branch_merged_into_default?(branch_name)
+          default_branch = resolve_default_branch
+          git_success?('merge-base', '--is-ancestor', branch_name, "origin/#{default_branch}")
+        end
+
         def create_new_branch_worktree(branch_name, target_dir)
           default_branch = resolve_default_branch
           if dry_run?
@@ -101,6 +134,33 @@ module Rails
           git!('worktree', 'remove', '--force', target_dir)
         end
 
+        def remove_target_path(target_dir)
+          if registered_worktree_path?(target_dir)
+            remove_registered_worktree(target_dir)
+          else
+            info("Removing existing target path '#{target_dir}'")
+            FileUtils.rm_rf(target_dir)
+          end
+        end
+
+        def delete_local_branch(branch_name, force: false)
+          ensure_local_branch_removable!(branch_name, force: force)
+
+          info("Deleting local branch '#{branch_name}'")
+          git!('branch', force ? '-D' : '-d', branch_name)
+        end
+
+        def ensure_local_branch_removable!(branch_name, force: false)
+          return if force
+
+          default_branch = resolve_default_branch
+          return if branch_merged_into_default?(branch_name)
+
+          raise Error,
+                "Local branch '#{branch_name}' is not merged into origin/#{default_branch}. " \
+                'Re-run with --force to delete it.'
+        end
+
         def git!(*)
           stdout_str, stderr_str, status = Open3.capture3(@env.to_h, 'git', *, chdir: @cwd)
           return stdout_str if status.success?
@@ -137,6 +197,7 @@ module Rails
           git!('worktree', 'add', '--force', target_dir, branch_name)
         end
       end
+      # rubocop:enable Metrics/ModuleLength
     end
   end
 end

data/lib/rails/worktrees/command/output.rb

@@ -2,6 +2,7 @@ module Rails
   module Worktrees
     class Command
       # User-facing output, prompts, and help text.
+      # rubocop:disable Metrics/ModuleLength
       module Output
         private
 
@@ -26,16 +27,20 @@ module Rails
         def usage
           <<~USAGE
             wt #{::Rails::Worktrees::VERSION}
-            Create Git worktrees for the current repository.
+            Create and clean up Git worktrees for the current repository.
 
             Usage: wt [worktree-name]
                    wt --dry-run [worktree-name]
                    wt --print-env <worktree-name>
+                   wt remove [--dry-run] [--force] <worktree-name>
+                   wt delete [--dry-run] [--force] <worktree-name>
+                   wt prune [--dry-run]
 
             Options:
               -h, --help                  Show this help message
               -v, --version               Show the script version
-              --dry-run [name]            Preview the full worktree setup without changing anything
+              --dry-run [name]            Preview worktree creation or cleanup without changing anything
+              --force                     Delete an unmerged local branch with wt remove/delete
               --env, --print-env <name>   Preview DEV_PORT and WORKTREE_DATABASE_SUFFIX
 
             Quick start:
@@ -43,12 +48,17 @@ module Rails
               wt my-feature      Use an explicit worktree name
               wt --dry-run my-feature
               wt --print-env my-feature
+              wt remove my-feature
+              wt remove --force my-feature
+              wt prune
 
             How it works:
               - by default creates worktrees beside the repo in ../<project>.worktrees/<name>
               - when workspace_root or WT_WORKSPACES_ROOT is set, creates worktrees in <root>/<project>/<name>
               - always uses the branch name #{@configuration.branch_prefix}/<name>
               - bases new branches on the repository's origin default branch
+              - wt remove/delete can run from the main checkout or any sibling worktree, but never remove the worktree you're currently in
+              - wt prune removes merged worktrees created by wt while skipping the main checkout and the checkout you're in
               - auto-discovers bundled *.txt files from #{@configuration.name_sources_path}
               - retires bundled names in #{@configuration.used_names_file}
           USAGE
@@ -75,7 +85,7 @@ module Rails
           @stdout.puts("→ #{message}")
         end
 
-        def announce_dry_run = info('Dry run: previewing worktree setup without making changes')
+        def announce_dry_run = info('Dry run: previewing worktree changes without applying them')
 
         def complete_dry_run(context, env_values:)
           success('Dry run complete')
@@ -90,6 +100,53 @@ module Rails
           complete_dry_run(context, env_values: preview_result&.values)
         end
 
+        def complete_remove_dry_run(context, worktree_exists:, branch_exists:)
+          info(remove_dry_run_target_message(context, worktree_exists: worktree_exists))
+          info(remove_dry_run_branch_message(context, branch_exists: branch_exists))
+
+          success('Dry run complete')
+          print_context_summary(context, env_values: nil)
+          info('No changes were made.')
+          0
+        end
+
+        def remove_dry_run_target_message(context, worktree_exists:)
+          return "Would skip worktree removal because '#{context[:target_dir]}' does not exist" unless worktree_exists
+
+          action = if registered_worktree_path?(context[:target_dir])
+                     'remove registered worktree at'
+                   else
+                     'remove existing target path'
+                   end
+          "Would #{action} '#{context[:target_dir]}'"
+        end
+
+        def remove_dry_run_branch_message(context, branch_exists:)
+          unless branch_exists
+            return "Would skip local branch deletion because '#{context[:branch_name]}' does not exist"
+          end
+
+          "Would delete local branch '#{context[:branch_name]}'"
+        end
+
+        def print_prune_candidates(candidates)
+          candidates.each do |context|
+            info("#{context[:worktree_name]} => #{context[:target_dir]} (#{context[:branch_name]})")
+          end
+        end
+
+        def complete_prune_noop
+          info('No merged worktrees created by wt are ready to prune.')
+          0
+        end
+
+        def complete_prune_dry_run(candidates)
+          info("Would prune #{candidates.length} merged worktree#{'s' unless candidates.length == 1}")
+          success('Dry run complete')
+          info('No changes were made.')
+          0
+        end
+
         def warning(message)
           @stderr.puts("⚠️  #{message}")
         end
@@ -124,6 +181,7 @@ module Rails
           @stdout.puts("Suffix: #{suffix}")
         end
       end
+      # rubocop:enable Metrics/ModuleLength
     end
   end
 end

data/lib/rails/worktrees/command/workspace_paths.rb

@@ -5,6 +5,28 @@ module Rails
       module WorkspacePaths
         private
 
+        def resolve_repository_context
+          current_root = canonical_path(git_capture('rev-parse', '--show-toplevel').strip)
+          common_dir = expand_git_path(git_capture('rev-parse', '--git-common-dir').strip)
+          primary_root = primary_checkout_root_for(current_root, common_dir)
+
+          repository_context_for(current_root, primary_root)
+        end
+
+        def repository_context_for(current_root, primary_root)
+          project_name = File.basename(primary_root)
+          workspaces = resolve_workspaces(primary_root, project_name)
+
+          {
+            current_root: current_root,
+            primary_root: primary_root,
+            project_name: project_name,
+            workspaces: workspaces,
+            workspaces_root: workspaces[:root],
+            uses_default_workspace_root: workspaces[:uses_default_root]
+          }
+        end
+
         def resolve_workspaces(repo_root, project_name)
           explicit_root = configured_workspaces_root
           return { root: explicit_root, uses_default_root: false } if explicit_root
@@ -38,6 +60,18 @@ module Rails
           FileUtils.mkdir_p(parent_dir)
         end
 
+        def primary_checkout_root_for(current_root, common_dir)
+          return current_root unless File.basename(common_dir) == '.git'
+
+          canonical_path(File.dirname(common_dir))
+        end
+
+        def expand_git_path(path)
+          return path if path.start_with?('/')
+
+          File.expand_path(path, @cwd)
+        end
+
         def present_path?(path)
           !path.nil? && !path.empty?
         end

data/lib/rails/worktrees/command.rb

@@ -10,6 +10,8 @@ module Rails
     # Creates or attaches worktrees for the current repository.
     # rubocop:disable Metrics/ClassLength
     class Command
+      REMOVE_SUBCOMMANDS = %w[remove delete].freeze
+
       include GitOperations
       include EnvironmentSupport
       include NamePicking
@@ -24,18 +26,14 @@ module Rails
         @env = env
         @cwd = cwd
         @configuration = configuration
-        @dry_run = @argv.first == '--dry-run'
-        @argv.shift if dry_run?
+        extract_flags!
       end
 
       def run
-        return usage_error if dry_run? && @argv.first&.start_with?('-')
-
         meta_command_result = handle_meta_command
         return meta_command_result unless meta_command_result.nil?
-        return usage_error if @argv.length > 1
 
-        execute_worktree_command
+        execute_requested_command
       rescue Error => e
         @stderr.puts("Error: #{e.message}")
         1
@@ -45,6 +43,40 @@ module Rails
 
       def dry_run? = @dry_run
 
+      def force? = @force
+
+      def extract_flags!
+        @dry_run = extract_flag!('--dry-run')
+        @force = extract_flag!('--force')
+      end
+
+      def extract_flag!(flag)
+        extracted = false
+        @argv.reject! do |arg|
+          next false unless arg == flag
+
+          extracted = true
+          true
+        end
+        extracted
+      end
+
+      def remove_subcommand?
+        REMOVE_SUBCOMMANDS.include?(@argv.first)
+      end
+
+      def prune_subcommand?
+        @argv.first == 'prune'
+      end
+
+      def execute_requested_command
+        return execute_remove_command if remove_subcommand?
+        return execute_prune_command if prune_subcommand?
+        return usage_error if @argv.length > 1 || force?
+
+        execute_worktree_command
+      end
+
       def execute_worktree_command
         require_git_repo
         announce_dry_run if dry_run?
@@ -61,16 +93,95 @@ module Rails
         finish(context)
       end
 
-      def resolve_worktree_context(explicit_worktree_name: nil)
-        repo_root = git_capture('rev-parse', '--show-toplevel').strip
-        project_name = File.basename(repo_root)
-        workspaces = resolve_workspaces(repo_root, project_name)
+      def execute_remove_command
+        require_git_repo
+        announce_dry_run if dry_run?
+        validate_remove_args!
+
+        context = resolve_worktree_context(explicit_worktree_name: @argv.fetch(1))
+        removal_status = removal_status_for(context)
+
+        ensure_removable!(context, **removal_status)
+        return complete_remove_dry_run(context, **removal_status) if dry_run?
+
+        perform_remove(context, **removal_status)
+      end
+
+      def validate_remove_args!
+        raise Error, "Usage: wt #{@argv.first} [--dry-run] [--force] <worktree-name>" unless @argv.length == 2
+      end
+
+      def removal_status_for(context)
+        {
+          worktree_exists: File.exist?(context[:target_dir]),
+          branch_exists: branch_exists_locally?(context[:branch_name])
+        }
+      end
+
+      def perform_remove(context, worktree_exists:, branch_exists:)
+        remove_target_path(context[:target_dir]) if worktree_exists
+        delete_local_branch(context[:branch_name], force: force?) if branch_exists
+
+        success("Removed '#{context[:worktree_name]}'")
+        print_context_summary(context, env_values: nil)
+        0
+      end
+
+      def execute_prune_command
+        require_git_repo
+        announce_dry_run if dry_run?
+        validate_prune_args!
+
+        candidates = prune_candidates
+        return complete_prune_noop if candidates.empty?
+
+        prepare_prune(candidates)
+        return complete_prune_dry_run(candidates) if dry_run?
+
+        perform_prune(candidates)
+
+        success("Pruned #{candidates.length} worktree#{'s' unless candidates.length == 1}")
+        0
+      end
+
+      def validate_prune_args!
+        raise Error, 'Usage: wt prune' unless @argv.length == 1
+        raise Error, 'The --force flag is only supported with wt remove.' if force?
+      end
+
+      def announce_prune_candidates(candidates)
+        info("Found #{candidates.length} merged worktree#{'s' unless candidates.length == 1} created by wt:")
+      end
+
+      def prepare_prune(candidates)
+        announce_prune_candidates(candidates)
+        print_prune_candidates(candidates)
+        confirm_or_abort!(prune_confirmation_prompt(candidates.length))
+      end
+
+      def prune_confirmation_prompt(count)
+        branches = count == 1 ? 'its local branch' : 'their local branches'
+        "Delete #{count} merged worktree#{'s' unless count == 1} and #{branches}?"
+      end
+
+      def perform_prune(candidates)
+        candidates.each do |context|
+          remove_target_path(context[:target_dir])
+          delete_local_branch(context[:branch_name], force: false)
+        end
+      end
+
+      def resolve_worktree_context(explicit_worktree_name: nil, repository: nil)
+        repository ||= resolve_repository_context
+        project_name = repository[:project_name]
+        workspaces = repository[:workspaces]
         worktree_name = resolved_worktree_name(project_name, workspaces, explicit_worktree_name)
 
-        { project_name: project_name, workspaces_root: workspaces[:root], worktree_name: worktree_name,
-          uses_default_workspace_root: workspaces[:uses_default_root],
+        repository.merge(
+          worktree_name: worktree_name,
           branch_name: branch_name_for(worktree_name),
-          target_dir: target_dir_for(project_name, worktree_name, workspaces) }
+          target_dir: target_dir_for(project_name, worktree_name, workspaces)
+        )
       end
 
       def resolved_worktree_name(project_name, workspaces, explicit_worktree_name)
@@ -133,16 +244,105 @@ module Rails
         confirm_or_abort!("Target path '#{target_dir}' already exists. Remove it and recreate the worktree?")
         return info("Would remove existing target path '#{target_dir}'") if dry_run?
 
-        if registered_worktree_path?(target_dir)
-          remove_registered_worktree(target_dir)
-        else
-          FileUtils.rm_rf(target_dir)
-        end
+        remove_target_path(target_dir)
       end
 
       def branch_name_for(worktree_name)
         "#{@configuration.branch_prefix}/#{worktree_name}"
       end
+
+      def ensure_removable!(context, worktree_exists:, branch_exists:)
+        ensure_remove_target_exists!(context, worktree_exists: worktree_exists, branch_exists: branch_exists)
+        ensure_not_removing_protected_checkout!(context)
+        ensure_branch_not_checked_out_here!(context)
+        ensure_branch_not_checked_out_elsewhere!(context)
+        ensure_local_branch_removable!(context[:branch_name], force: force?) if branch_exists
+      end
+
+      def ensure_remove_target_exists!(context, worktree_exists:, branch_exists:)
+        return if worktree_exists || branch_exists
+
+        raise Error, "No worktree or local branch found for '#{context[:worktree_name]}'."
+      end
+
+      def ensure_not_removing_protected_checkout!(context)
+        target_path = canonical_path(context[:target_dir])
+        raise Error, 'Cannot remove the main checkout.' if target_path == canonical_path(context[:primary_root])
+
+        return unless target_path == canonical_path(context[:current_root])
+
+        raise Error,
+              'Cannot remove the current worktree from inside itself. ' \
+              'Run this command from the main checkout or another worktree.'
+      end
+
+      def ensure_branch_not_checked_out_here!(context)
+        return unless current_checkout_branch == context[:branch_name]
+
+        raise Error,
+              "Branch '#{context[:branch_name]}' is checked out in the current worktree. " \
+              'Run this command from the main checkout or another worktree.'
+      end
+
+      def ensure_branch_not_checked_out_elsewhere!(context)
+        target_path = canonical_path(context[:target_dir])
+        unexpected_paths = worktree_entries_for_branch(context[:branch_name])
+                           .map { |entry| entry[:path] }
+                           .reject { |path| path == target_path }
+        return if unexpected_paths.empty?
+
+        raise Error,
+              "Branch '#{context[:branch_name]}' is checked out in another worktree at '#{unexpected_paths.first}'."
+      end
+
+      def prune_candidates
+        repository = resolve_repository_context
+
+        worktree_entries.filter_map do |entry|
+          prune_candidate_for(entry, repository)
+        end
+      end
+
+      def prune_candidate_for(entry, repository)
+        branch_name = entry[:branch_name]
+        return unless prunable_worktree_entry?(entry, branch_name, repository)
+
+        context = resolve_worktree_context(
+          explicit_worktree_name: worktree_name_for_branch(branch_name),
+          repository: repository
+        )
+        return unless prune_target_matches_entry?(entry, context)
+
+        context
+      end
+
+      def prunable_worktree_entry?(entry, branch_name, repository)
+        wt_managed_branch?(branch_name) &&
+          !protected_prune_path?(entry[:path], repository) &&
+          !branch_checked_out_elsewhere_for_prune?(branch_name, entry[:path]) &&
+          branch_exists_locally?(branch_name) &&
+          branch_merged_into_default?(branch_name)
+      end
+
+      def branch_checked_out_elsewhere_for_prune?(branch_name, target_path)
+        worktree_entries_for_branch(branch_name).any? { |other| other[:path] != target_path }
+      end
+
+      def prune_target_matches_entry?(entry, context)
+        entry[:path] == canonical_path(context[:target_dir])
+      end
+
+      def protected_prune_path?(path, repository)
+        path == repository[:primary_root] || path == repository[:current_root]
+      end
+
+      def wt_managed_branch?(branch_name)
+        branch_name&.start_with?("#{@configuration.branch_prefix}/")
+      end
+
+      def worktree_name_for_branch(branch_name)
+        branch_name.delete_prefix("#{@configuration.branch_prefix}/")
+      end
     end
     # rubocop:enable Metrics/ClassLength
   end

data/lib/rails/worktrees/version.rb

@@ -1,5 +1,5 @@
 module Rails
   module Worktrees
-    VERSION = '0.3.0'.freeze
+    VERSION = '0.4.0'.freeze
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-worktrees
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Asjer Querido