rails-worktree 0.1.6 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e7212fc3b6e29ec0889e74aa816833e5709c61ffe580138d793eb7e32774b9e
-  data.tar.gz: 40ffa81276288089b12c97655fda37718fc34ca3414ff475acb961afc073fd9c
+  metadata.gz: cd8698c3bbb798a625214a84c2f0e6cc585b4759cd9ef6ae9d3806eb6e6c572a
+  data.tar.gz: 98611afb823f7b713a6c12412232d1cc6e85ef023eaad9b0518bb211aa41e628
 SHA512:
-  metadata.gz: b0c3ecb5d1e2ba749a205172ba8eb5cfe1fc85fcdf96daa7e55194b92f647fb21497c59e980cab8505854a9c4d034211513b5232a2319e53d4ba12b3f7f44ac2
-  data.tar.gz: 9d215b260bd60c01c3494d840f022b95ead4f86010632118f8290b738ab021a1c40f9588e550e60aa9a6aa05c2c991e57f7c3e16b99355f2541a0268c70ae49a
+  metadata.gz: 71ce31463125cb9756e54f0b66f0b153f39cc8658a9af88c6d8a2a726c22521b5ac5649d5b0a204bfc9775f4c925bfe77648120c734a13953b77eff3781345d2
+  data.tar.gz: 96f6e366bdd38b682df8735b368ac26c2b56398bb750d278b0d1556af99cdb7cd97ff811628ce6ed53aaf8d9f061717488d8a84757f354b2d4d03f67802aaed0

data/README.md

@@ -4,7 +4,9 @@ Git worktree management for Rails projects with isolated databases and configura
 
 ## Features
 
-- Create git worktrees with automatic branch creation
+- Create git worktrees from an explicit base with automatic branch creation
+- Run commands with worktree-local Bundler and binstubs
+- Verify the recorded base before execution and push
 - Isolated databases per worktree (separate development and test databases)
 - Automatic configuration file copying
 - Copy node_modules from main worktree
@@ -21,6 +23,8 @@ end
 ```
 
 Run `bundle install`. A binstub will be automatically created at `bin/worktree`.
+When Rails loads in development, installation also adds `/.worktrees/` to the project's
+`.gitignore`. The manual installer does the same, including when the binstub already exists.
 
 Manual binstub installation (if needed):
 ```bash
@@ -32,16 +36,75 @@ bundle exec rake worktree:install
 ### Create a worktree
 
 ```bash
-bin/worktree feature-branch         # From current branch
-bin/worktree feature-branch main    # From specific branch
+git fetch origin
+bin/worktree feature-branch origin/main  # Explicit base required
 ```
 
+The base is required: omitting it fails before creating a branch or directory. The exact local
+commit resolved from that reference is recorded; creation does not fetch or change your base branch.
+Worktrees are created under `.worktrees/` in the repository root, including when invoked from a subdirectory.
+
 This creates a new worktree with:
 - Separate databases: `myapp_feature-branch_development` and `myapp_feature-branch_test`
 - Copied configuration files (`.env`, `database.yml`, `Procfile.dev`, credentials)
 - Copied `node_modules`
 - Migrated and seeded databases
 
+### Run commands in the worktree
+
+```bash
+cd .worktrees/feature-branch
+bin/worktree exec -- bundle exec rspec
+bin/worktree exec -- bin/rails db:migrate
+bin/worktree verify
+```
+
+`exec` runs from the Git worktree root, including when called from a subdirectory. It checks the
+recorded branch and base ancestry, verifies Bundler's effective root in a fresh Ruby process, and
+pins `BUNDLE_GEMFILE` to this worktree. It clears inherited Bundler state and Git directory overrides,
+removes other repositories' `bin` directories from PATH, and puts this checkout's `bin` first.
+An explicit `bundle` command uses Bundler's gem executable rather than an inherited project binstub.
+Initialization commands use the same isolated environment.
+
+Direct commands, `bundle exec` commands, and Ruby script invocations reject binstubs that resolve
+into another repository, including symlinks. Arguments are passed directly without shell expansion;
+command exit status is preserved. Use an explicit `sh -c` when shell syntax is intended. This wrapper
+is an execution-context guard, not a sandbox: it does not inspect shell scripts or prevent application
+code from spawning commands elsewhere. Commands run outside the wrapper are not intercepted.
+
+Generated `bin/worktree` launchers are shell scripts that set `BUNDLE_GEMFILE` before starting Ruby,
+so an inherited `RUBYOPT=-rbundler/setup` cannot activate the previous checkout's bundle first.
+Both automatic installation and the Rake installer use the same generator. To replace an existing
+launcher in a project after updating the gem:
+
+```bash
+bundle exec rake worktree:install FORCE=1
+```
+
+Creation replaces the new worktree's launcher with the current generator. Symlinked launchers
+are refused rather than followed. Existing worktrees without recorded metadata cannot use `exec`
+or `verify`; create a managed worktree from an explicit base to use these checks.
+
+### Verify before pushing
+
+Creation stores the base reference, its resolved commit, and the feature branch in the private
+`rails-worktree.json` file under `git rev-parse --git-dir`. It does not add this metadata to tracked
+project files. The recorded commit remains fixed even if the base reference advances.
+
+Creation also installs a pre-push wrapper at Git's configured hook location, including a custom
+`core.hooksPath`. An existing hook is preserved as `pre-push.before-rails-worktree` and runs after
+verification with the same arguments and input. Its exit status is preserved. Repeated installation
+is idempotent; an unexpected existing backup causes an actionable error instead of overwriting it.
+
+In managed worktrees the hook checks the branch, base ancestry, and bundle root, then prints the
+change summary against the recorded base. Non-deletion updates must push the current HEAD; push
+other branches from their own checkout. In checkouts without metadata, the wrapper only runs the
+previous hook. Git hooks are shared by worktrees unless configured otherwise.
+
+A branch mismatch tells you to switch back; a base mismatch tells you to rebase onto the recorded
+base. These checks cannot decide whether you chose the right base or whether a change belongs in
+the feature. Review the printed diff before publishing. Git's `--no-verify` still bypasses hooks.
+
 ### Close a worktree
 
 ```bash

data/lib/rails-worktree.rb

@@ -1,12 +1,17 @@
+module RailsWorktree
+  class Error < StandardError; end
+end
+
 require_relative "worktree/version"
+require_relative "worktree/context"
+require_relative "worktree/launcher"
+require_relative "worktree/installer"
+require_relative "worktree/push_hook"
 require_relative "worktree/cli"
 require_relative "worktree/commands/create"
 require_relative "worktree/commands/init"
 require_relative "worktree/commands/close"
+require_relative "worktree/commands/exec"
 
 # Load Railtie only if Rails is available
 require_relative "worktree/railtie" if defined?(Rails::Railtie)
-
-module RailsWorktree
-  class Error < StandardError; end
-end

data/lib/worktree/cli.rb

@@ -5,7 +5,7 @@ module RailsWorktree
     end
 
     def initialize(args)
-      @args = args
+      @args = args.dup
     end
 
     def run
@@ -14,6 +14,13 @@ module RailsWorktree
         exit 1
       end
 
+      case @args.first
+      when "exec"
+        return Commands::Exec.new(@args.drop(1)).run
+      when "verify"
+        return Context.new.verify(push: @args.include?("--push"))
+      end
+
       # Extract flags
       @skip_seeds = @args.delete("--skip-seeds")
 
@@ -30,20 +37,27 @@ module RailsWorktree
         # Default: create worktree
         Commands::Create.new(@args, skip_seeds: @skip_seeds).run
       end
+    rescue Error => error
+      warn "Error: #{error.message}"
+      exit 1
     end
 
     private
 
     def print_usage
       puts <<~USAGE
-        Usage: worktree <name> [base-branch] [options]
+        Usage: worktree <name> <base-branch> [options]
                worktree --close [worktree-name]
+               worktree exec -- <command> [arguments]
+               worktree verify [--push]
                worktree --init <worktree-name> [options]
 
         Creates a new git worktree and initializes it with configuration
 
         Commands:
           <name>              Create a new worktree with the given name
+          exec -- COMMAND     Run a command with verified worktree context
+          verify              Check the recorded base and bundle root
           --close [name]      Close and remove a worktree
           --init <name>       Initialize a worktree (usually called automatically)
           --help, -h          Show this help message
@@ -53,11 +67,11 @@ module RailsWorktree
 
         Arguments:
           <name>              Name of the worktree (required)
-          [base-branch]       Branch to create worktree from (default: current branch)
+          <base-branch>       Explicit branch or commit to create worktree from (required)
 
         Examples:
-          worktree feature-branch                  # Create new worktree
-          worktree feature-branch --skip-seeds     # Create without seeding database
+          worktree feature-branch origin/main      # Create from an explicit base
+          worktree feature-branch origin/main --skip-seeds     # Create without seeding database
           worktree --close feature-branch          # Close worktree from main repo
           worktree --close                         # Close worktree from within it
       USAGE

data/lib/worktree/commands/close.rb

@@ -22,11 +22,11 @@ module RailsWorktree
         puts "Main worktree: #{@main_worktree}"
         puts ""
 
-        # Move to main worktree early so we're not inside the directory we're about to delete
-        Dir.chdir(@main_worktree) unless @in_main_repo
-
         drop_databases
         remove_node_modules
+
+        # Move to main worktree so we're not inside the directory we're about to delete
+        Dir.chdir(@main_worktree) unless @in_main_repo
         remove_worktree
         prune_worktrees
         delete_branch
@@ -79,7 +79,7 @@ module RailsWorktree
       def detect_paths
         if @current_dir == @main_worktree
           @in_main_repo = true
-          @worktree_path = File.join(File.dirname(@main_worktree), @worktree_name)
+          @worktree_path = File.join(@main_worktree, ".worktrees", @worktree_name)
           @worktree_dir = @worktree_path
         else
           @in_main_repo = false
@@ -91,16 +91,13 @@ module RailsWorktree
       def drop_databases
         puts "Dropping databases..."
 
-        if system("dropdb", "--if-exists", @dev_database_name)
-          puts "Dropped database '#{@dev_database_name}'"
-        else
-          puts "Warning: Could not drop development database #{@dev_database_name}"
-        end
-
-        if system("dropdb", "--if-exists", @test_database_name)
-          puts "Dropped database '#{@test_database_name}'"
-        else
-          puts "Warning: Could not drop test database #{@test_database_name}"
+        Dir.chdir(@worktree_path) do
+          if File.executable?("bin/rails")
+            system({ "DISABLE_DATABASE_ENVIRONMENT_CHECK" => "1" }, "bin/rails", "db:drop") ||
+              puts("Warning: Could not drop databases")
+          else
+            puts "Warning: bin/rails not found in worktree, skipping database drop"
+          end
         end
       end
 

data/lib/worktree/commands/create.rb

@@ -1,3 +1,5 @@
+require "fileutils"
+
 module RailsWorktree
   module Commands
     class Create
@@ -13,13 +15,31 @@ module RailsWorktree
           exit 1
         end
 
-        @base_branch ||= current_branch
-        worktree_path = "../#{@worktree_name}"
+        raise Error, "Base branch required: bin/worktree #{@worktree_name} BASE (for example origin/main)." unless @base_branch
+        context = Context.new
+        Dir.chdir(context.root) { create }
+      end
+
+      private
+
+      def create
+        _output, error, status = Open3.capture3(Context::GIT_ENVIRONMENT, "git", "check-ref-format", "--branch", @worktree_name)
+        raise Error, "Invalid worktree branch: #{error.strip}" unless status.success?
+        output, error, status = Open3.capture3(Context::GIT_ENVIRONMENT, "git", "rev-parse", "--verify", "--end-of-options", "#{@base_branch}^{commit}")
+        raise Error, "Invalid base #{@base_branch}: #{error.strip}" unless status.success?
+        base_commit = output.strip
+        worktree_dir = ".worktrees"
+        worktree_path = "#{worktree_dir}/#{@worktree_name}"
         absolute_path = File.expand_path(worktree_path)
 
+        raise Error, "Worktree name must stay inside .worktrees" unless absolute_path.start_with?(File.expand_path(worktree_dir) + File::SEPARATOR)
+
+        Installer.ignore_worktrees(Dir.pwd)
+        FileUtils.mkdir_p(worktree_dir)
+
         puts "Creating worktree '#{@worktree_name}' from branch '#{@base_branch}' at #{worktree_path}..."
 
-        unless system("git worktree add -b #{@worktree_name} #{worktree_path} #{@base_branch}")
+        unless system(Context::GIT_ENVIRONMENT, "git", "worktree", "add", "-b", @worktree_name, worktree_path, base_commit)
           puts "Failed to create worktree"
           exit 1
         end
@@ -30,6 +50,11 @@ module RailsWorktree
         puts "Initializing worktree..."
 
         Dir.chdir(worktree_path) do
+          created = Context.new
+          created.record(@base_branch, base_commit, @worktree_name)
+          created.verify
+          Installer.install(created.root, replace: true)
+          PushHook.install(created.root)
           Init.new([@worktree_name], skip_seeds: @skip_seeds).run
         end
 
@@ -39,12 +64,6 @@ module RailsWorktree
         puts ""
         puts "To start the development server: bin/dev"
       end
-
-      private
-
-      def current_branch
-        `git branch --show-current`.strip
-      end
     end
   end
 end

data/lib/worktree/commands/exec.rb

@@ -0,0 +1,19 @@
+module RailsWorktree
+  module Commands
+    class Exec
+      def initialize(args)
+        @args = args.dup
+        @args.shift if @args.first == "--"
+      end
+
+      def run
+        context = Context.new
+        context.verify
+        command = context.command(@args)
+        system(context.environment, [command.first, command.first], *command.drop(1), chdir: context.root, unsetenv_others: true)
+        status = $?
+        exit(status.exitstatus || 128 + status.termsig)
+      end
+    end
+  end
+end

data/lib/worktree/commands/init.rb

@@ -25,6 +25,9 @@ module RailsWorktree
         puts "Development database: #{@dev_database_name}"
         puts "Test database: #{@test_database_name}"
 
+        @context = Context.new
+        @context_environment = @context.environment
+
         copy_config_files
         set_database_names
         update_database_yml
@@ -65,9 +68,11 @@ module RailsWorktree
           ".env",
           "config/database.yml",
           "Procfile.dev",
-          "config/credentials/development.key"
+          "config/master.key"
         ]
 
+        files_to_copy += Dir.glob("config/credentials/*", base: @main_worktree)
+
         files_to_copy.each do |file|
           source = File.join(@main_worktree, file)
           if File.exist?(source)
@@ -112,13 +117,17 @@ module RailsWorktree
 
         content = File.read(database_yml)
 
-        # Replace original database names with worktree-specific ones wherever they appear
-        # This handles hardcoded names, ERB defaults, env var defaults, etc.
-        original_dev = "#{@db_prefix}_development"
-        original_test = "#{@db_prefix}_test"
-
-        content.gsub!(original_dev, @dev_database_name)
-        content.gsub!(original_test, @test_database_name)
+        # Use a single-pass replacement to avoid one substitution creating
+        # a substring that matches the other pattern (e.g., replacing
+        # "app_development" first produces "app_test-branch_development",
+        # which contains "app_test" and would be wrongly matched by a
+        # second gsub for the test pattern).
+        replacements = {
+          "#{@db_prefix}_development" => @dev_database_name,
+          "#{@db_prefix}_test" => @test_database_name
+        }
+        pattern = Regexp.union(replacements.keys)
+        content.gsub!(pattern) { |match| replacements[match] }
 
         File.write(database_yml, content)
       end
@@ -135,28 +144,34 @@ module RailsWorktree
       end
 
       def database_env
-        {
+        (@context_environment || {}).merge(
+          "BUNDLE_GEMFILE" => File.expand_path("Gemfile"),
           "DATABASE_NAME_DEVELOPMENT" => @dev_database_name,
           "DATABASE_NAME_TEST" => @test_database_name
-        }
+        )
+      end
+
+      def run_command(environment, *arguments)
+        command = @context ? @context.command(arguments) : arguments
+        system(environment, *command, unsetenv_others: !!@context_environment)
       end
 
       def setup_database
         if File.executable?("bin/setup")
           puts "Running bin/setup..."
-          system(database_env, "bin/setup") || puts("Warning: bin/setup failed")
+          run_command(database_env, "bin/setup") || puts("Warning: bin/setup failed")
         else
           puts "Creating databases..."
-          system(database_env.merge("RAILS_ENV" => "development"), "bin/rails", "db:create") || puts("Warning: Could not create development database")
-          system(database_env.merge("RAILS_ENV" => "test"), "bin/rails", "db:create") || puts("Warning: Could not create test database")
+          run_command(database_env.merge("RAILS_ENV" => "development"), "bin/rails", "db:create") || puts("Warning: Could not create development database")
+          run_command(database_env.merge("RAILS_ENV" => "test"), "bin/rails", "db:create") || puts("Warning: Could not create test database")
 
           puts "Running migrations..."
-          system(database_env.merge("RAILS_ENV" => "development"), "bin/rails", "db:migrate") || puts("Warning: Could not run migrations")
-          system(database_env.merge("RAILS_ENV" => "test"), "bin/rails", "db:migrate") || puts("Warning: Could not run test migrations")
+          run_command(database_env.merge("RAILS_ENV" => "development"), "bin/rails", "db:migrate") || puts("Warning: Could not run migrations")
+          run_command(database_env.merge("RAILS_ENV" => "test"), "bin/rails", "db:migrate") || puts("Warning: Could not run test migrations")
 
           unless @skip_seeds
             puts "Seeding development database..."
-            system(database_env.merge("RAILS_ENV" => "development"), "bin/rails", "db:seed") || puts("Warning: Could not seed database")
+            run_command(database_env.merge("RAILS_ENV" => "development"), "bin/rails", "db:seed") || puts("Warning: Could not seed database")
           else
             puts "Skipping database seeding..."
           end

data/lib/worktree/context.rb

@@ -0,0 +1,132 @@
+require "json"
+require "open3"
+require "rbconfig"
+require "bundler"
+
+module RailsWorktree
+  class Context
+    GIT_ENVIRONMENT = {"GIT_DIR" => nil, "GIT_WORK_TREE" => nil, "GIT_INDEX_FILE" => nil, "GIT_COMMON_DIR" => nil}.freeze
+
+    attr_reader :root
+
+    def initialize(directory = Dir.pwd)
+      @root = File.realpath(git(directory, "rev-parse", "--show-toplevel").strip)
+    end
+
+    def record(base, commit, branch)
+      File.write(metadata_path, JSON.pretty_generate({"base" => base, "commit" => commit, "branch" => branch}) + "\n")
+    end
+
+    def verify(push: false)
+      data = JSON.parse(File.read(metadata_path))
+      raise Error, "Invalid worktree context in #{metadata_path}; expected an object with base, commit and branch." unless data.is_a?(Hash)
+      verify_branch(data)
+      verify_base(data)
+      verify_bundle
+      verify_push(data) if push
+      data
+    rescue Errno::ENOENT, JSON::ParserError, KeyError => error
+      raise Error, "Missing or invalid worktree context. Recreate with an explicit base using worktree NAME BASE. #{error.message}"
+    end
+
+    def environment
+      env = Bundler.respond_to?(:unbundled_env) ? Bundler.unbundled_env : Bundler.clean_env
+      env["PATH"] = executable_path(env.fetch("PATH", ""))
+      env["BUNDLE_GEMFILE"] = File.join(root, "Gemfile")
+      env.delete("BUNDLE_BIN_PATH")
+      GIT_ENVIRONMENT.each_key { |key| env.delete(key) }
+      env
+    end
+
+    def command(arguments)
+      raise Error, "Command required: bin/worktree exec -- bundle exec rspec" if arguments.empty?
+      arguments = arguments.dup
+      invoked = arguments[0, 2] == ["bundle", "exec"] ? arguments.drop(2) : arguments
+      candidates = invoked.first == "bundle" ? [] : [invoked.first]
+      candidates << invoked[1] if invoked.first && File.basename(invoked.first) == "ruby"
+      candidates.compact.each { |path| verify_binstub(path) }
+      if arguments.first == "bundle"
+        arguments.shift
+        [RbConfig.ruby, Gem.bin_path("bundler", "bundle"), *arguments]
+      else
+        arguments
+      end
+    end
+
+    def metadata_path
+      File.expand_path(git(root, "rev-parse", "--git-path", "rails-worktree.json").strip, root)
+    end
+
+    private
+
+    def executable_path(path)
+      worktree_bins = git(root, "worktree", "list", "--porcelain").lines.grep(/^worktree /).map do |line|
+        File.join(line.delete_prefix("worktree ").strip, "bin")
+      end
+      paths = path.split(File::PATH_SEPARATOR).reject do |directory|
+        worktree_bins.include?(directory) || foreign_bin_directory?(directory)
+      end
+      ([File.join(root, "bin")] + paths).uniq.join(File::PATH_SEPARATOR)
+    end
+
+    def verify_branch(data)
+      branch = git(root, "branch", "--show-current").strip
+      raise Error, "Worktree branch differs from recorded #{data.fetch("branch")}; switch back before continuing." unless branch == data.fetch("branch")
+    end
+
+    def verify_base(data)
+      git(root, "merge-base", "--is-ancestor", data.fetch("commit"), "HEAD")
+    rescue Error
+      raise Error, "Recorded base #{data.fetch("base")} is no longer an ancestor of HEAD. Rebase onto that base before continuing."
+    end
+
+    def verify_bundle
+      gemfile = File.join(root, "Gemfile")
+      raise Error, "Missing worktree Gemfile: #{gemfile}" unless File.file?(gemfile) && File.realpath(gemfile) == gemfile
+
+      output, error, status = Open3.capture3(environment, RbConfig.ruby, "-rbundler", "-e", "puts Bundler.root.realpath", chdir: root, unsetenv_others: true)
+      unless status.success? && output.strip == root
+        raise Error, "Bundle resolves outside this worktree or cannot load. Run through bin/worktree exec. #{error.strip}"
+      end
+    end
+
+    def verify_push(data)
+      unless $stdin.tty?
+        head = git(root, "rev-parse", "HEAD").strip
+        $stdin.each_line do |line|
+          _local_ref, sha, _remote_ref, _remote_sha = line.split
+          next if sha && sha.match?(/\A0+\z/)
+          raise Error, "Push includes a commit other than this worktree's HEAD. Push the current branch separately." unless sha == head
+        end
+      end
+      puts "Worktree base: #{data.fetch("base")} (#{data.fetch("commit")})"
+      puts git(root, "diff", "--stat", "#{data.fetch("commit")}...HEAD", "--")
+    end
+
+    def foreign_bin_directory?(path)
+      return false unless File.basename(path) == "bin" && File.directory?(path)
+      output, _error, status = Open3.capture3(GIT_ENVIRONMENT, "git", "-C", path, "rev-parse", "--show-toplevel")
+      status.success? && File.realpath(output.strip) != root
+    end
+
+    def verify_binstub(path)
+      resolved = if path.include?(File::SEPARATOR)
+        File.expand_path(path, root)
+      else
+        environment.fetch("PATH").split(File::PATH_SEPARATOR).map { |dir| File.join(dir, path) }.find { |file| File.executable?(file) && !File.directory?(file) }
+      end
+      return unless resolved && File.exist?(resolved)
+      resolved = File.realpath(resolved)
+      return if resolved.start_with?(root + File::SEPARATOR)
+      return unless resolved.include?("/bin/")
+      _output, _error, status = Open3.capture3(GIT_ENVIRONMENT, "git", "-C", File.dirname(resolved), "rev-parse", "--show-toplevel")
+      raise Error, "Binstub resolves outside this worktree: #{resolved}. Use this checkout's binstub through bin/worktree exec." if status.success?
+    end
+
+    def git(directory, *arguments)
+      output, error, status = Open3.capture3(GIT_ENVIRONMENT, "git", "-C", directory, *arguments)
+      raise Error, "Git context check failed (#{arguments.join(" ")}): #{error.strip}" unless status.success?
+      output
+    end
+  end
+end

data/lib/worktree/installer.rb

@@ -0,0 +1,19 @@
+module RailsWorktree
+  class Installer
+    def self.install(root, replace: false)
+      Launcher.install(root, replace: replace)
+      ignore_worktrees(root)
+    end
+
+    def self.ignore_worktrees(root)
+      path = File.join(root, ".gitignore")
+      content = File.exist?(path) ? File.read(path) : ""
+      return if content.lines.any? { |line| %w[ .worktrees .worktrees/ /.worktrees /.worktrees/ ].include?(line.strip) }
+
+      File.open(path, "a") do |file|
+        file.puts unless content.empty? || content.end_with?("\n")
+        file.puts "/.worktrees/"
+      end
+    end
+  end
+end

data/lib/worktree/launcher.rb

@@ -0,0 +1,22 @@
+require "fileutils"
+
+module RailsWorktree
+  class Launcher
+    def self.install(root, replace: false)
+      path = File.join(root, "bin/worktree")
+      return if File.exist?(path) && !replace
+      FileUtils.mkdir_p(File.dirname(path))
+      raise Error, "Launcher points outside this worktree: #{path}" unless File.realpath(File.dirname(path)).start_with?(File.realpath(root) + File::SEPARATOR)
+      raise Error, "Refusing to replace a symlinked launcher: #{path}" if File.symlink?(path)
+      File.write(path, <<~'SH')
+        #!/bin/sh
+        # Set the bundle before Ruby processes an inherited -rbundler/setup.
+        worktree_root=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd -P) || exit 1
+        export BUNDLE_GEMFILE="$worktree_root/Gemfile"
+        unset BUNDLE_BIN_PATH
+        exec ruby -e 'require "bundler/setup"; require "rails-worktree"; RailsWorktree::CLI.run(ARGV)' -- "$@"
+      SH
+      File.chmod(0755, path)
+    end
+  end
+end

data/lib/worktree/push_hook.rb

@@ -0,0 +1,48 @@
+require "fileutils"
+require "open3"
+require "rbconfig"
+
+module RailsWorktree
+  class PushHook
+    MARKER = "# rails-worktree context hook"
+
+    def self.install(root)
+      output, error, status = Open3.capture3(Context::GIT_ENVIRONMENT, "git", "-C", root, "rev-parse", "--git-path", "hooks/pre-push")
+      raise Error, "Cannot locate pre-push hook: #{error}" unless status.success?
+      path = File.expand_path(output.strip, root)
+      return if File.file?(path) && File.read(path).include?(MARKER)
+      previous = "#{path}.before-rails-worktree"
+      raise Error, "Hook backup already exists: #{previous}; restore it before installing the worktree hook." if File.exist?(previous)
+      FileUtils.mkdir_p(File.dirname(path))
+      FileUtils.mv(path, previous) if File.exist?(path)
+      File.write(path, <<~RUBY)
+        #!#{RbConfig.ruby}
+        #{MARKER}
+        require "open3"
+        require "tempfile"
+        root, _, status = Open3.capture3("git", "rev-parse", "--show-toplevel")
+        exit 1 unless status.success?
+        root = root.strip
+        metadata, _, status = Open3.capture3("git", "rev-parse", "--git-path", "rails-worktree.json")
+        exit 1 unless status.success?
+        Tempfile.create("worktree-push") do |input|
+          input.write($stdin.read)
+          input.flush
+          input.rewind
+          if File.file?(File.expand_path(metadata.strip, root))
+            launcher = File.join(root, "bin/worktree")
+            abort "Missing bin/worktree; reinstall the worktree launcher before pushing." unless File.executable?(launcher)
+            exit 1 unless system({"BUNDLE_GEMFILE" => File.join(root, "Gemfile")}, launcher, "verify", "--push", in: input)
+          end
+          previous = __FILE__ + ".before-rails-worktree"
+          if File.executable?(previous)
+            input.rewind
+            system([previous, previous], *ARGV, in: input)
+            exit($?.exitstatus || 128 + $?.termsig)
+          end
+        end
+      RUBY
+      File.chmod(0755, path)
+    end
+  end
+end

data/lib/worktree/railtie.rb

@@ -11,23 +11,7 @@ module RailsWorktree
     initializer "worktree.install_binstub" do
       # Install binstub automatically when Rails loads in development
       if Rails.env.development?
-        binstub_path = Rails.root.join("bin/worktree")
-
-        unless File.exist?(binstub_path)
-          Rails.logger.info "Installing worktree binstub to bin/worktree..."
-
-          File.write(binstub_path, <<~RUBY)
-            #!/usr/bin/env ruby
-
-            require "bundler/setup"
-            require "rails-worktree"
-
-            RailsWorktree::CLI.run(ARGV)
-          RUBY
-
-          FileUtils.chmod("+x", binstub_path)
-          Rails.logger.info "✓ Worktree binstub installed! Use: bin/worktree <name>"
-        end
+        Installer.install(Rails.root.to_s)
       end
     end
   end

data/lib/worktree/tasks.rb

@@ -1,26 +1,10 @@
 namespace :worktree do
-  desc "Install worktree binstub to bin/worktree"
+  desc "Install bin/worktree and ignore local .worktrees"
   task :install do
-    binstub_path = File.join(Dir.pwd, "bin/worktree")
-
-    if File.exist?(binstub_path)
-      puts "Binstub already exists at bin/worktree"
-      exit 0
-    end
-
-    File.write(binstub_path, <<~RUBY)
-      #!/usr/bin/env ruby
-
-      require "bundler/setup"
-      require "rails-worktree"
-
-      RailsWorktree::CLI.run(ARGV)
-    RUBY
-
-    File.chmod(0755, binstub_path)
+    RailsWorktree::Installer.install(Dir.pwd, replace: ENV["FORCE"] == "1")
 
-    puts "✓ Worktree binstub installed to bin/worktree"
-    puts "Usage: bin/worktree <name>"
+    puts "✓ bin/worktree is installed and .worktrees is ignored"
+    puts "Usage: bin/worktree <name> <base-branch>"
   end
 
   desc "Uninstall worktree binstub from bin/worktree"

data/lib/worktree/version.rb

@@ -1,3 +1,3 @@
 module RailsWorktree
-  VERSION = "0.1.6"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-worktree
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.2.0
 platform: ruby
 authors:
 - Martin Ulleberg
@@ -24,7 +24,12 @@ files:
 - lib/worktree/cli.rb
 - lib/worktree/commands/close.rb
 - lib/worktree/commands/create.rb
+- lib/worktree/commands/exec.rb
 - lib/worktree/commands/init.rb
+- lib/worktree/context.rb
+- lib/worktree/installer.rb
+- lib/worktree/launcher.rb
+- lib/worktree/push_hook.rb
 - lib/worktree/railtie.rb
 - lib/worktree/tasks.rb
 - lib/worktree/version.rb