rails-worktrees 0.2.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19ad567125176f17f962138eaf218f8e8c91a7a6585b61db0bddfa4c259f7d17
-  data.tar.gz: 7c29590624ed404c362deb38866f134ba9516bbd3e6f83f3b04cfb00792caeb4
+  metadata.gz: 46dd1369d93b3281d8182a90812164a1a245ff778b5af05306908989563e264e
+  data.tar.gz: 0d7e33ae49a56ea819e3a07ebfde966e1b1c18677af8c406bd15e93628ba8aff
 SHA512:
-  metadata.gz: f35103be9855cc4e262f12b4dbff0ff935cb65b67d3ae6d2ca619eb1d47bdfcf8829be5b03f2d8ff3cc587509098045d32ccea539fa48395a02c6180ca69546b
-  data.tar.gz: ef54f096ea64e518519b59f9f74af756bec7601ee492c0d1aec98736c485e62998cc6ec9149b251fa903f4acdb39f5e8cc36e4ed66aa650357df76090c3fd67b
+  metadata.gz: 3d9e25b8d52ec84eb983d5b5ba28679394396232f61b8e9b626cf8a8f464b49e53d9f1898d0591bcd78e66620fa2b59869b1c781ed03b7a8a5f176f973a2ebbb
+  data.tar.gz: 795403173d6b6c8c375119b7427bebc620cc73deb9402a8c1c6aa25c863b703af882b4e4b01dd9bdbd123696f1949a1e00f830a92a227e93ddff3e09a1c763ee

data/.release-please-manifest.json

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

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # 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)
+
+
+### Features
+
+* **ob:** add `bin/ob` cli for opening `localhost:$DEV_PORT` routes in the browser ([1c94ade](https://github.com/asjer/rails-worktrees/commit/1c94adebd338cfe6e344095f3d6df089570f1e82))
+
 ## [0.2.2](https://github.com/asjer/rails-worktrees/compare/v0.2.1...v0.2.2) (2026-03-30)
 
 
@@ -42,6 +56,7 @@
 ## [Unreleased]
 
 - Add a gem-managed `wt` CLI for creating Rails worktrees.
+- Add an optional gem-managed `ob` CLI plus generated `bin/ob` wrapper for opening `localhost:$DEV_PORT` routes.
 - Add a Rails installer generator that creates `bin/wt` and `config/initializers/rails_worktrees.rb`.
 - Add conservative `config/database.yml` patching for common development/test database names.
 - Add a manual-dispatch GitHub Actions workflow for the disposable Rails smoke test.

data/README.md

@@ -1,6 +1,6 @@
 # Rails::Worktrees
 
-`rails-worktrees` adds a Rails-friendly `bin/wt` command for creating Git worktrees with isolated development and test databases.
+`rails-worktrees` adds Rails-friendly `bin/wt` and `bin/ob` commands for creating Git worktrees and opening the right local browser URL for each worktree.
 
 ## Requirements
 
@@ -13,6 +13,8 @@
 ```bash
 bundle add rails-worktrees
 bin/rails generate worktrees:install
+# or, to also generate bin/ob without the yolo follow-ups:
+bin/rails generate worktrees:install --browser
 # or, to apply the common Procfile.dev + Puma + mise follow-ups automatically:
 bin/rails generate worktrees:install --yolo
 ```
@@ -20,12 +22,14 @@ bin/rails generate worktrees:install --yolo
 The installer adds:
 
 - `bin/wt` — a thin wrapper that executes the gem-owned CLI
+- `bin/ob` — an optional browser helper generated by `--browser` or `--yolo`
 - `config/initializers/rails_worktrees.rb` — optional configuration
 - `Procfile.dev.worktree.example` — a copy-paste helper for `${DEV_PORT:-3000}` in `Procfile.dev` on regular installs
 - a safe update to `config/database.yml` for common development/test database names
 
 With `--yolo`, the installer also:
 
+- generates `bin/ob`
 - skips `Procfile.dev.worktree.example`
 - replaces the existing `web:` entry in `Procfile.dev` with the DEV_PORT-aware command when `Procfile.dev` already exists
 - updates `config/puma.rb` to use `port ENV['DEV_PORT'] || ENV.fetch('PORT', 3000)` when it still uses a supported default `PORT` binding
@@ -38,6 +42,15 @@ 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
+bin/ob '/contact?from=nav'      # open a local route with query params
+bin/ob --print-url '?from=nav'  # print the resolved URL without opening a browser
 ```
 
 ### Options
@@ -46,7 +59,8 @@ bin/wt --print-env my-feature   # preview DEV_PORT and WORKTREE_DATABASE_SUFFIX
 |------|-------------|
 | `-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
@@ -71,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:
@@ -79,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
@@ -124,6 +166,33 @@ When `bin/wt` creates a worktree it writes a worktree-local `.env` with:
 
 Existing `.env` values are never overwritten.
 
+### Browser helper
+
+If you install with `--browser` or `--yolo`, the installer generates `bin/ob`.
+
+`bin/ob` reads `DEV_PORT` from the current app or worktree's `.env`, falls back to `ENV['DEV_PORT']`, then falls back to `3000`, and opens `http://localhost:$DEV_PORT/...` in your default browser.
+
+Route examples:
+
+```bash
+bin/ob
+bin/ob contact
+bin/ob admin/users
+bin/ob '/contact?from=footer'
+bin/ob --print-url '?from=footer'
+```
+
+`bin/ob` accepts a single optional local route argument. Query-only routes such as `?from=footer` resolve to the app root, and full URLs such as `https://example.com` are intentionally rejected.
+
+If `DEV_PORT` is missing from `.env`, `bin/ob` tells you when it falls back to `ENV['DEV_PORT']` or `3000`.
+
+Browser opening currently uses:
+
+- `open` on macOS
+- `xdg-open` on Linux and other Unix-like environments that provide it
+
+For scripts and debugging, `bin/ob --print-url [route]` prints the resolved localhost URL without opening a browser.
+
 By default, the installer does **not** edit your `Procfile.dev`, `config/puma.rb`, or `mise` config. It generates `Procfile.dev.worktree.example` with a ready-to-copy line:
 
 ```text
@@ -160,8 +229,8 @@ This smoke test:
 - creates a temporary Rails app from a compatible Rails version
 - installs `rails-worktrees` from the current checkout path
 - runs `bin/rails generate worktrees:install --yolo`
-- verifies `bin/wt`, 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
+- 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`, 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/exe/ob

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+lib = File.expand_path('../lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'rails/worktrees'
+
+exit(
+  Rails::Worktrees::BrowserCommand.new(
+    argv: ARGV,
+    io: { stdin: $stdin, stdout: $stdout, stderr: $stderr },
+    env: ENV,
+    cwd: Dir.pwd
+  ).run
+)

data/lib/generators/rails/worktrees/templates/bin/ob

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+ENV['RAILS_WORKTREES_APP_ROOT'] ||= File.expand_path('..', __dir__)
+
+require 'bundler/setup'
+load Gem.bin_path('rails-worktrees', 'ob')

data/lib/generators/worktrees/install/install_generator.rb

@@ -17,12 +17,24 @@ module Worktrees
       include ::Rails::Worktrees::Generators::PumaFollowUp
 
       namespace 'worktrees:install'
-      desc 'Installs bin/wt, a Rails::Worktrees initializer, and updates config/database.yml when safe.'
+      desc [
+        'Installs bin/wt, optional bin/ob, a Rails::Worktrees initializer,',
+        'and updates config/database.yml when safe.'
+      ].join(' ')
       source_root File.expand_path('../../rails/worktrees/templates', __dir__)
       class_option :conductor, type: :boolean, default: false,
                                desc: 'Configure the installer for ~/Sites/conductor/workspaces'
-      class_option :yolo, type: :boolean, default: false,
-                          desc: 'Apply common Procfile.dev, config/puma.rb, and mise .env follow-up edits when safe'
+      class_option :browser,
+                   type: :boolean,
+                   default: false,
+                   desc: 'Generate bin/ob to open localhost:$DEV_PORT routes for this app/worktree'
+      class_option :yolo,
+                   type: :boolean,
+                   default: false,
+                   desc: [
+                     'Apply common Procfile.dev, config/puma.rb, and mise .env',
+                     'follow-up edits when safe; also generate bin/ob'
+                   ].join(' ')
 
       FOLLOW_UP_TEMPLATE = <<~TEXT.freeze
           ============================================
@@ -46,6 +58,13 @@ module Worktrees
         chmod('bin/wt', 0o755)
       end
 
+      def create_browser_wrapper
+        return unless install_browser_wrapper?
+
+        template('bin/ob', 'bin/ob')
+        chmod('bin/ob', 0o755)
+      end
+
       def create_initializer
         template('rails_worktrees.rb.tt', 'config/initializers/rails_worktrees.rb')
       end
@@ -124,7 +143,7 @@ module Worktrees
       end
 
       def follow_up_notes_text
-        [super, puma_follow_up_notes_text].join
+        [super, browser_follow_up_notes_text, puma_follow_up_notes_text].join
       end
 
       def installed_items_text
@@ -132,6 +151,7 @@ module Worktrees
           '      • bin/wt',
           '      • config/initializers/rails_worktrees.rb'
         ]
+        items << '      • bin/ob' if install_browser_wrapper?
         items << '      • Procfile.dev.worktree.example' unless options[:yolo]
         items << database_follow_up_line if database_follow_up_line
         items.join("\n")
@@ -211,6 +231,22 @@ module Worktrees
         say('Skipped mise yolo update because no supported mise config file was found.')
       end
 
+      def browser_follow_up_notes_text
+        return '' unless install_browser_wrapper?
+
+        [
+          '',
+          '      Open browser:',
+          '        $ bin/ob',
+          '        $ bin/ob contact',
+          "        $ bin/ob --print-url '?from=nav'"
+        ].join("\n")
+      end
+
+      def install_browser_wrapper?
+        options[:yolo] || options[:browser]
+      end
+
       def git_repo?
         _stdout_str, _stderr_str, status = Open3.capture3(
           'git', 'rev-parse', '--is-inside-work-tree', chdir: destination_root

data/lib/rails/worktrees/browser_command.rb

@@ -0,0 +1,264 @@
+require 'rbconfig'
+require 'uri'
+
+module Rails
+  module Worktrees
+    # Opens the current app/worktree in a browser using the local DEV_PORT.
+    # rubocop:disable Metrics/ClassLength
+    class BrowserCommand
+      APP_ROOT_ENV_KEY = 'RAILS_WORKTREES_APP_ROOT'.freeze
+      ENV_FILE_NAME = '.env'.freeze
+
+      def initialize(argv:, io:, env:, cwd:, host_os: RbConfig::CONFIG['host_os'])
+        @argv = argv.dup
+        @stdin = io.fetch(:stdin)
+        @stdout = io.fetch(:stdout)
+        @stderr = io.fetch(:stderr)
+        @env = env
+        @cwd = cwd
+        @host_os = host_os
+      end
+
+      def run
+        meta_command_result = handle_meta_command
+        return meta_command_result unless meta_command_result.nil?
+        return usage_error if @argv.length > 1
+
+        url = build_url(@argv.first)
+        open_browser(url)
+        @stdout.puts("🌐 Opening #{url}")
+        0
+      rescue Error => e
+        @stderr.puts("Error: #{e.message}")
+        1
+      end
+
+      private
+
+      def handle_meta_command
+        case @argv.first
+        when '-h', '--help'
+          @stdout.print(usage)
+          0
+        when '-v', '--version'
+          @stdout.puts("ob #{Rails::Worktrees::VERSION}")
+          0
+        when '--url', '--print-url'
+          print_url_command
+        end
+      end
+
+      def usage_error
+        @stderr.print(usage)
+        1
+      end
+
+      def usage
+        <<~USAGE
+          ob #{::Rails::Worktrees::VERSION}
+          Open the current app/worktree in your browser using DEV_PORT.
+
+          Usage: ob [route]
+                 ob --print-url [route]
+
+          Options:
+            -h, --help              Show this help message
+            -v, --version           Show the script version
+            --url, --print-url      Print the resolved URL without opening a browser
+
+          Quick start:
+            ob
+            ob contact
+            ob '/contact?ref=nav'
+            ob --print-url '?from=nav'
+
+          Route rules:
+            - route is optional; the default is /
+            - values like contact and admin/users become /contact and /admin/users
+            - query-only values like ?from=nav resolve to /?from=nav
+            - full URLs are rejected; ob only opens localhost routes
+            - DEV_PORT comes from .env first, then ENV['DEV_PORT'], then 3000
+        USAGE
+      end
+
+      def build_url(route)
+        raise Error, 'ob only accepts local routes, not full URLs' if full_url?(route)
+
+        path, query, fragment = route_components(route)
+        uri_options = { host: 'localhost', port: resolved_dev_port.to_i, path: path, query: query, fragment: fragment }
+        URI::HTTP.build(**uri_options).to_s
+      rescue URI::Error => e
+        raise Error, "Invalid route: #{e.message}"
+      end
+
+      def route_components(route)
+        raw_route = route.to_s.strip
+        route_without_fragment, fragment = raw_route.split('#', 2)
+        path_part, query = route_without_fragment.to_s.split('?', 2)
+
+        [normalized_path(path_part), presence(query), presence(fragment)]
+      end
+
+      def normalized_path(path_part)
+        cleaned = path_part.to_s
+        return '/' if cleaned.empty?
+
+        cleaned.start_with?('/') ? cleaned : "/#{cleaned}"
+      end
+
+      def resolved_dev_port
+        info = dev_port_resolution
+        note_port_fallback(info[:message])
+
+        port = info.fetch(:port)
+        raise Error, "DEV_PORT must be numeric, got #{port.inspect}" unless port.match?(/\A\d+\z/)
+        raise Error, "DEV_PORT must be between 1 and 65535, got #{port.inspect}" unless (1..65_535).cover?(port.to_i)
+
+        port.to_i
+      end
+
+      def print_url_command
+        return usage_error if @argv.length > 2
+
+        @stdout.puts(build_url(@argv[1]))
+        0
+      end
+
+      def dev_port_from_env_file
+        return unless File.file?(env_path)
+
+        lines = File.readlines(env_path, chomp: true)
+        env_value(lines, 'DEV_PORT')
+      rescue StandardError => e
+        raise Error, "Could not read #{env_path}: #{e.message}"
+      end
+
+      def env_value(lines, key)
+        line = lines.reverse.find { |entry| entry.start_with?("#{key}=") }
+        value = line&.split('=', 2)&.last
+        value unless value&.empty?
+      end
+
+      def dev_port_resolution
+        env_file_port = dev_port_from_env_file
+        return { port: env_file_port, message: nil } if env_file_port
+
+        env_file_fallback_resolution
+      end
+
+      def env_file_fallback_resolution
+        env_port = presence(@env['DEV_PORT'])
+        return existing_env_file_resolution(env_port) if File.file?(env_path)
+
+        missing_env_file_resolution(env_port)
+      end
+
+      def existing_env_file_resolution(env_port)
+        return env_resolution_from_env_var(env_port) if env_port
+
+        {
+          port: '3000',
+          message: [
+            "#{env_path} does not define DEV_PORT",
+            "and ENV['DEV_PORT'] is unset; falling back to localhost:3000."
+          ].join(' ')
+        }
+      end
+
+      def missing_env_file_resolution(env_port)
+        return missing_env_file_resolution_from_env_var(env_port) if env_port
+
+        {
+          port: '3000',
+          message: [
+            "#{env_path} was not found",
+            "and ENV['DEV_PORT'] is unset; falling back to localhost:3000."
+          ].join(' ')
+        }
+      end
+
+      def env_resolution_from_env_var(env_port)
+        {
+          port: env_port,
+          message: "#{env_path} does not define DEV_PORT; falling back to ENV['DEV_PORT']=#{env_port}."
+        }
+      end
+
+      def missing_env_file_resolution_from_env_var(env_port)
+        {
+          port: env_port,
+          message: "#{env_path} was not found; falling back to ENV['DEV_PORT']=#{env_port}."
+        }
+      end
+
+      def note_port_fallback(message)
+        return unless message
+        return if @port_fallback_noted
+
+        @stderr.puts("Info: #{message}")
+        @port_fallback_noted = true
+      end
+
+      def open_browser(url)
+        command = opener_command
+        raise Error, "Could not find a browser opener for #{@host_os.inspect}" unless command
+        raise Error, "Failed to open browser with #{command}" unless run_opener(command, url)
+      end
+
+      def opener_command
+        opener_candidates.find { |command| command_available?(command) }
+      end
+
+      def run_opener(command, url)
+        system(command, url)
+      end
+
+      def command_available?(command)
+        @env.fetch('PATH', '').split(File::PATH_SEPARATOR).any? do |directory|
+          candidate = File.join(directory, command)
+          File.file?(candidate) && File.executable?(candidate)
+        end
+      end
+
+      def opener_candidates
+        return ['open'] if @host_os.match?(/darwin/i)
+
+        ['xdg-open']
+      end
+
+      def env_path = File.join(app_root, ENV_FILE_NAME)
+
+      def app_root
+        @app_root ||= begin
+          explicit_root = presence(@env[APP_ROOT_ENV_KEY])
+          explicit_root ? File.expand_path(explicit_root) : discover_app_root(File.expand_path(@cwd))
+        end
+      end
+
+      def discover_app_root(start_dir)
+        current = start_dir
+
+        loop do
+          return current if File.file?(File.join(current, 'Gemfile'))
+
+          parent = File.dirname(current)
+          break if parent == current
+
+          current = parent
+        end
+
+        start_dir
+      end
+
+      def full_url?(route)
+        route.to_s.match?(%r{\A[a-z][a-z0-9+\-.]*://}i)
+      end
+
+      def presence(value)
+        value = value.to_s
+        value.empty? ? nil : value
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

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.2.2'.freeze
+    VERSION = '0.4.0'.freeze
   end
 end

data/lib/rails/worktrees.rb

@@ -5,6 +5,7 @@ require_relative 'worktrees/configuration'
 require_relative 'worktrees/env_bootstrapper'
 require_relative 'worktrees/command'
 require_relative 'worktrees/cli'
+require_relative 'worktrees/browser_command'
 require_relative 'worktrees/database_config_updater'
 require_relative 'worktrees/procfile_updater'
 require_relative 'worktrees/mise_toml_updater'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-worktrees
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Asjer Querido
@@ -34,6 +34,7 @@ description: Rails::Worktrees is a Ruby gem intended to support working with git
 email:
 - asjer@johnyontherun.com
 executables:
+- ob
 - wt
 extensions: []
 extra_rdoc_files: []
@@ -43,15 +44,18 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- exe/ob
 - exe/wt
 - lefthook.yml
 - lib/generators/rails/worktrees/mise_follow_up.rb
 - lib/generators/rails/worktrees/puma_follow_up.rb
 - lib/generators/rails/worktrees/templates/Procfile.dev.worktree.example.tt
+- lib/generators/rails/worktrees/templates/bin/ob
 - lib/generators/rails/worktrees/templates/bin/wt
 - lib/generators/rails/worktrees/templates/rails_worktrees.rb.tt
 - lib/generators/worktrees/install/install_generator.rb
 - lib/rails/worktrees.rb
+- lib/rails/worktrees/browser_command.rb
 - lib/rails/worktrees/cli.rb
 - lib/rails/worktrees/command.rb
 - lib/rails/worktrees/command/environment_support.rb