rails-worktrees 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f11c54fe45c6061774b7181c80c7a25ba1c824d04fe06668ca0d6fe0bc3c453
-  data.tar.gz: 9470d8a967f77f0188679e8f9b50fd5a78c4aebe6f10e268cba00ffaff1ebea0
+  metadata.gz: de8cd30214f81e827aee0e2fabba426a1c0cfca6f172d03fb36fad408fc8bfe7
+  data.tar.gz: 604eb3468c743e91b3b5ad19f9943fa94d9fe891b45732de491ddc8219c4b943
 SHA512:
-  metadata.gz: c3775b72de293d0cf888f9b94cbbeae5b6031f001c641a1365f8f2662caa38de8b04bd4235a4e5c3f7b81279f6a23ce4637f4b2cfa6d6e1ba9d0fd0619daede2
-  data.tar.gz: 0c07249ae8bad61d6ae0cdad68f58752579145175e0d43005772e0d91f2f04b8d672f99a1952ce168e881d04e0b88ab4bbb8603183d4a9a2ace12f5c1767584e
+  metadata.gz: 8f33f141355afb0dbc9ee06cdaab2e2f242c7d49b7ac72b6c2aa21202aabc8fb709cf79aa88a0b43f2357240b19b88dab37cc284f3fd4f712cc2b6c1057b743b
+  data.tar.gz: c9bc8caa8f38b496e2d7dd4bc0693251ec18606863b349cf949398e2cc131c448277869e04ac873e80f8b3dfff3f1fc59604e7ba2207fff21a97c255376524f3

data/.release-please-manifest.json

@@ -1 +1 @@
-{".":"0.5.0"}
+{".":"0.6.0"}

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.6.0](https://github.com/asjer/rails-worktrees/compare/v0.5.1...v0.6.0) (2026-04-03)
+
+
+### Features
+
+* **post-create:** bootstrap new worktrees after creation ([b429105](https://github.com/asjer/rails-worktrees/commit/b42910507d21c1d048d45cfdc4d7311a1ec8a96b))
+
+## [0.5.1](https://github.com/asjer/rails-worktrees/compare/v0.5.0...v0.5.1) (2026-04-02)
+
+
+### Bug Fixes
+
+* **initializer:** simplify generated config wiring ([bd7fd50](https://github.com/asjer/rails-worktrees/commit/bd7fd506f2c0106a0bd188e36b31329a9de2acbf))
+
 ## [0.5.0](https://github.com/asjer/rails-worktrees/compare/v0.4.0...v0.5.0) (2026-04-02)
 
 

data/README.md

@@ -19,7 +19,7 @@ bin/rails generate worktrees:install --browser
 bin/rails generate worktrees:install --yolo
 ```
 
-The generated initializer checks that `rails-worktrees` is actually loaded before it calls `Rails::Worktrees.configure`, so the app can still boot in environments like `test` when the gem is only bundled for `:development`.
+The generated initializer writes app config under `Rails.application.config.x.rails_worktrees`, so the file stays safe to load even in environments like `test` where the gem is only bundled for `:development`. When `rails-worktrees` is loaded, the gem applies those settings for both the CLI and in-process Rails usage.
 
 The installer adds:
 
@@ -148,7 +148,7 @@ Worktree names must not contain `/` or whitespace, must not be `.` or `..`, and
 
 The installer generates `config/initializers/rails_worktrees.rb` where you can override:
 
-The initializer becomes a no-op whenever `rails-worktrees` is not loaded in the current bundle groups.
+The initializer stays app-owned and gem-agnostic; `rails-worktrees` reads those settings whenever the gem is present in the current bundle groups.
 
 | Option | Default | Description |
 |--------|---------|-------------|

data/lib/generators/rails/worktrees/templates/rails_worktrees.rb.tt

@@ -1,23 +1,30 @@
-if Gem.loaded_specs.key?('rails-worktrees') &&
-    defined?(Rails::Worktrees) &&
-    Rails::Worktrees.respond_to?(:configure)
-  Rails::Worktrees.configure do |config|
+Rails.application.config.x.rails_worktrees.tap do |config|
 <% if options['conductor'] -%>
-    config.workspace_root = <%= conductor_workspace_root %>
+  config.workspace_root = <%= conductor_workspace_root %>
 <% else -%>
-    # By default, worktrees go in a sibling "<project>.worktrees" directory.
-    # Uncomment to override with a custom parent directory that uses <root>/<project>/<name>.
-    # config.workspace_root = File.expand_path('~/worktrees')
+  # By default, worktrees go in a sibling "<project>.worktrees" directory.
+  # Uncomment to override with a custom parent directory that uses <root>/<project>/<name>.
+  # config.workspace_root = File.expand_path('~/worktrees')
 <% end -%>
-    # config.bootstrap_env = false
-    # config.dev_port_range = 3000..3999
-    # config.worktree_database_suffix_max_length = 18
-    # config.branch_prefix = '🚂'
-    # config.name_sources_path = Rails.root.join('config/worktree_names').to_s
-    # config.used_names_file = File.join(
-    #   ENV.fetch('XDG_STATE_HOME', File.expand_path('~/.local/state')),
-    #   'rails-worktrees',
-    #   'used-names.tsv'
-    # )
-  end
-end
+  # config.bootstrap_env = false
+  # config.dev_port_range = 3000..3999
+  # config.worktree_database_suffix_max_length = 18
+  # config.branch_prefix = '🚂'
+  # config.name_sources_path = Rails.root.join('config/worktree_names').to_s
+  # config.used_names_file = File.join(
+  #   ENV.fetch('XDG_STATE_HOME', File.expand_path('~/.local/state')),
+  #   'rails-worktrees',
+  #   'used-names.tsv'
+  # )
+
+  # Post-create setup steps (run automatically after a new worktree is created)
+  # config.post_create_command = nil    # nil = built-in steps; false = skip all; 'script/worktree-setup' = custom command
+  # config.run_bundle_install = true
+  # config.run_yarn_install = true      # auto-skipped when yarn.lock is absent
+  # config.run_db_prepare = true
+  # config.run_test_db_prepare = true
+  # config.run_test_assets_precompile = true
+  # config.link_credential_keys = true  # link development.key from a sibling worktree (opt-out)
+  # config.link_test_credential_key = false
+  # config.link_production_credential_key = false
+end

data/lib/rails/worktrees/application_configuration.rb

@@ -0,0 +1,36 @@
+module Rails
+  module Worktrees
+    # Copies explicit app configuration values onto the runtime configuration object.
+    module ApplicationConfiguration
+      module_function
+
+      def apply(source, configuration:)
+        return configuration unless source
+
+        Configuration::CONFIGURABLE_ATTRIBUTES.each do |attribute|
+          next unless assigned?(source, attribute)
+
+          configuration.public_send("#{attribute}=", value_for(source, attribute))
+        end
+
+        configuration
+      end
+
+      def assigned?(source, attribute)
+        key = attribute.to_sym
+        hash = source.is_a?(Hash) ? source : source.to_h if source.respond_to?(:to_h)
+        return hash.key?(key) || hash.key?(attribute.to_s) if hash
+
+        source.respond_to?(:key?) && (source.key?(key) || source.key?(attribute.to_s))
+      end
+
+      def value_for(source, attribute)
+        key = attribute.to_sym
+        hash = source.is_a?(Hash) ? source : source.to_h if source.respond_to?(:to_h)
+        return hash.fetch(key) { hash[attribute.to_s] } if hash
+
+        source.public_send(attribute)
+      end
+    end
+  end
+end

data/lib/rails/worktrees/cli.rb

@@ -2,6 +2,9 @@ module Rails
   module Worktrees
     # Shell entrypoint for the wt executable.
     class CLI
+      LOADER_OPTIONAL_COMMANDS = %w[doctor update -h --help -v --version].freeze
+      LOADER_IGNORED_FLAGS = %w[--dry-run --force].freeze
+
       def initialize(
         argv: ARGV,
         io: { stdin: $stdin, stdout: $stdout, stderr: $stderr },
@@ -15,13 +18,36 @@ module Rails
       end
 
       def start
-        Command.new(
-          argv: @argv,
-          io: @io,
-          env: @env,
-          cwd: @cwd,
-          configuration: ::Rails::Worktrees.configuration
-        ).run
+        configuration = ::Rails::Worktrees.configuration
+        load_project_configuration(configuration) if should_load_project_configuration?
+        command_for(configuration).run
+      rescue ::Rails::Worktrees::Error => e
+        @io.fetch(:stderr).puts("Error: #{e.message}")
+        1
+      end
+
+      private
+
+      def load_project_configuration(configuration)
+        ::Rails::Worktrees::ProjectConfigurationLoader.new(root: @cwd, configuration: configuration).call
+      rescue StandardError, ScriptError => e
+        raise ::Rails::Worktrees::Error, "Failed to load worktrees configuration: #{e.class}: #{e.message}"
+      end
+
+      def should_load_project_configuration?
+        argv_without_flags.empty? || !loader_optional_command?(argv_without_flags.first)
+      end
+
+      def argv_without_flags
+        @argv.reject { |arg| LOADER_IGNORED_FLAGS.include?(arg) }
+      end
+
+      def loader_optional_command?(command)
+        LOADER_OPTIONAL_COMMANDS.include?(command)
+      end
+
+      def command_for(configuration)
+        Command.new(argv: @argv, io: @io, env: @env, cwd: @cwd, configuration: configuration)
       end
     end
   end

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

@@ -0,0 +1,33 @@
+module Rails
+  module Worktrees
+    class Command
+      # Delegates post-create setup steps to PostCreateRunner.
+      module PostCreateSupport
+        private
+
+        def run_post_create_steps(context)
+          post_create_runner_for(context).call(dry_run: false)
+        end
+
+        def preview_post_create_steps(context)
+          post_create_runner_for(context).call(dry_run: true)
+        end
+
+        def post_create_runner_for(context)
+          PostCreateRunner.new(
+            target_dir: context[:target_dir],
+            peer_roots: peer_roots_excluding(context[:target_dir]),
+            configuration: @configuration,
+            io: { stdout: @stdout, stderr: @stderr }
+          )
+        end
+
+        def peer_roots_excluding(target_dir)
+          worktree_entries
+            .map { |entry| entry[:path] }
+            .reject { |path| path == target_dir }
+        end
+      end
+    end
+  end
+end

data/lib/rails/worktrees/command.rb

@@ -3,6 +3,7 @@ require_relative 'command/environment_support'
 require_relative 'command/git_operations'
 require_relative 'command/name_picking'
 require_relative 'command/output'
+require_relative 'command/post_create_support'
 require_relative 'command/workspace_paths'
 
 module Rails
@@ -18,6 +19,7 @@ module Rails
       include EnvironmentSupport
       include NamePicking
       include Output
+      include PostCreateSupport
       include WorkspacePaths
 
       def initialize(argv:, io:, env:, cwd:, configuration:)
@@ -284,7 +286,20 @@ module Rails
       def finish(context)
         settle_retired_name(context[:worktree_name], context[:project_name], dry_run: dry_run?)
         bootstrap_result = bootstrap_worktree_environment(context)
-        return complete_dry_run(context, env_values: bootstrap_result&.values) if dry_run?
+
+        return complete_dry_run_after_setup(context, bootstrap_result) if dry_run?
+
+        complete_created_worktree(context, bootstrap_result)
+      end
+
+      def complete_dry_run_after_setup(context, bootstrap_result)
+        preview_post_create_steps(context)
+        complete_dry_run(context, env_values: bootstrap_result&.values)
+      end
+
+      def complete_created_worktree(context, bootstrap_result)
+        result = run_post_create_steps(context)
+        return result unless result.zero?
 
         success('Worktree ready')
         print_context_summary(context, env_values: bootstrap_result&.values)

data/lib/rails/worktrees/configuration.rb

@@ -2,6 +2,25 @@ module Rails
   module Worktrees
     # Stores application-level settings for the wt command.
     class Configuration
+      CONFIGURABLE_ATTRIBUTES = %i[
+        bootstrap_env
+        workspace_root
+        dev_port_range
+        branch_prefix
+        name_sources_path
+        used_names_file
+        worktree_database_suffix_max_length
+        post_create_command
+        run_bundle_install
+        run_yarn_install
+        run_db_prepare
+        run_test_db_prepare
+        run_test_assets_precompile
+        link_credential_keys
+        link_test_credential_key
+        link_production_credential_key
+      ].freeze
+
       DEFAULT_BOOTSTRAP_ENV = true
       DEFAULT_BRANCH_PREFIX = '🚂'.freeze
       DEFAULT_DEV_PORT_RANGE = (3000..3999)
@@ -15,9 +34,20 @@ module Rails
 
       attr_accessor :bootstrap_env, :branch_prefix, :dev_port_range, :legacy_used_names_files,
                     :name_sources_path, :used_names_file, :workspace_root,
-                    :worktree_database_suffix_max_length
+                    :worktree_database_suffix_max_length,
+                    :post_create_command,
+                    :run_bundle_install, :run_yarn_install,
+                    :run_db_prepare, :run_test_db_prepare, :run_test_assets_precompile,
+                    :link_credential_keys, :link_test_credential_key, :link_production_credential_key
 
       def initialize
+        assign_core_defaults
+        assign_post_create_defaults
+      end
+
+      private
+
+      def assign_core_defaults
         @bootstrap_env = DEFAULT_BOOTSTRAP_ENV
         @workspace_root = nil
         @branch_prefix = DEFAULT_BRANCH_PREFIX
@@ -28,7 +58,17 @@ module Rails
         @legacy_used_names_files = default_legacy_used_names_files
       end
 
-      private
+      def assign_post_create_defaults
+        @post_create_command = nil
+        @run_bundle_install = true
+        @run_yarn_install = true
+        @run_db_prepare = true
+        @run_test_db_prepare = true
+        @run_test_assets_precompile = true
+        @link_credential_keys = true
+        @link_test_credential_key = false
+        @link_production_credential_key = false
+      end
 
       def default_legacy_used_names_files
         state_home = ENV.fetch('XDG_STATE_HOME', File.join(Dir.home, '.local/state'))

data/lib/rails/worktrees/credential_key_linker.rb

@@ -0,0 +1,93 @@
+require 'fileutils'
+
+module Rails
+  module Worktrees
+    # Links credential key files from a sibling worktree into the new worktree.
+    class CredentialKeyLinker
+      Result = Struct.new(:messages)
+
+      CREDENTIALS_DIR = 'config/credentials'.freeze
+
+      KEY_TYPES = [
+        { name: 'development', config_attr: :link_credential_keys },
+        { name: 'test',        config_attr: :link_test_credential_key },
+        { name: 'production',  config_attr: :link_production_credential_key }
+      ].freeze
+
+      def initialize(target_dir:, peer_roots:, configuration:)
+        @target_dir = target_dir
+        @peer_roots = peer_roots
+        @configuration = configuration
+      end
+
+      def call(dry_run: false)
+        messages = []
+
+        KEY_TYPES.each do |key_type|
+          next unless @configuration.public_send(key_type[:config_attr])
+
+          message = process_key(key_type[:name], dry_run: dry_run)
+          messages << message if message
+        end
+
+        Result.new(messages)
+      end
+
+      private
+
+      def process_key(key_name, dry_run:)
+        destination = destination_path_for(key_name)
+        existing_message = existing_destination_message(destination, key_name)
+        return existing_message if existing_message
+
+        replace_existing_symlink = File.symlink?(destination)
+        return "#{key_name}.key already exists; leaving as-is" if File.exist?(destination)
+
+        source = find_source(key_name)
+        return "Could not find source for #{key_name}.key" unless source
+
+        link_key(destination, key_name, source, dry_run: dry_run, replace_existing_symlink: replace_existing_symlink)
+      end
+
+      def find_source(key_name)
+        @peer_roots.each do |peer_root|
+          candidate = File.join(peer_root, CREDENTIALS_DIR, "#{key_name}.key")
+          next if File.expand_path(peer_root) == File.expand_path(@target_dir)
+
+          return candidate if File.file?(candidate)
+        end
+
+        nil
+      end
+
+      def destination_path_for(key_name)
+        File.join(@target_dir, CREDENTIALS_DIR, "#{key_name}.key")
+      end
+
+      def existing_destination_message(destination, key_name)
+        return unless File.symlink?(destination) && File.exist?(destination)
+
+        "#{key_name}.key already linked"
+      end
+
+      def link_key(destination, key_name, source, dry_run:, replace_existing_symlink: false)
+        return dry_run_link_message(key_name, source, replace_existing_symlink) if dry_run
+
+        FileUtils.mkdir_p(File.dirname(destination))
+        FileUtils.rm_f(destination) if replace_existing_symlink
+        File.symlink(source, destination)
+        linked_key_message(key_name, source, replace_existing_symlink)
+      end
+
+      def dry_run_link_message(key_name, source, replace_existing_symlink)
+        verb = replace_existing_symlink ? 'Would relink' : 'Would link'
+        "#{verb} #{key_name}.key → #{source}"
+      end
+
+      def linked_key_message(key_name, source, replace_existing_symlink)
+        verb = replace_existing_symlink ? 'Relinked' : 'Linked'
+        "#{verb} #{key_name}.key → #{source}"
+      end
+    end
+  end
+end

data/lib/rails/worktrees/initializer_updater.rb

@@ -2,7 +2,7 @@ require 'erb'
 
 module Rails
   module Worktrees
-    # Safely updates the generated initializer to use the current gem-loading guard.
+    # Safely updates the generated initializer to use the current managed app-config format.
     # rubocop:disable Metrics/ClassLength
     class InitializerUpdater
       Result = Struct.new(:content, :changed, :status, :messages) do
@@ -12,18 +12,13 @@ module Rails
       end
 
       TEMPLATE_PATH = File.expand_path('../../generators/rails/worktrees/templates/rails_worktrees.rb.tt', __dir__)
-      CURRENT_GUARD_LINES = [
-        "if Gem.loaded_specs.key?('rails-worktrees') &&",
-        '    defined?(Rails::Worktrees) &&',
-        '    Rails::Worktrees.respond_to?(:configure)'
-      ].freeze
+      CURRENT_WRAPPER_CALL = 'Rails.application.config.x.rails_worktrees.tap do |config|'.freeze
+      CONFIGURE_CALL = 'Rails::Worktrees.configure do |config|'.freeze
       KNOWN_GUARD_FRAGMENTS = [
         "Gem.loaded_specs.key?('rails-worktrees')",
         'defined?(Rails::Worktrees)',
         'Rails::Worktrees.respond_to?(:configure)'
       ].freeze
-      CONFIGURE_CALL = 'Rails::Worktrees.configure do |config|'.freeze
-      LEGACY_GUARD = /\Aif defined\?\(Rails::Worktrees\)\n(?<body>.*)\nend\z/m
 
       def self.default_content = new(content: '').send(:render_default_template)
 
@@ -46,7 +41,7 @@ module Rails
           @content,
           false,
           :identical,
-          ['config/initializers/rails_worktrees.rb already uses the current safety guard.']
+          ['config/initializers/rails_worktrees.rb already uses the current managed initializer format.']
         )
       end
 
@@ -55,7 +50,7 @@ module Rails
           content,
           content != @content,
           :updated,
-          ['Updated config/initializers/rails_worktrees.rb to use the current safety guard.']
+          ['Updated config/initializers/rails_worktrees.rb to use the current managed initializer format.']
         )
       end
 
@@ -70,19 +65,20 @@ module Rails
 
       def blank_content? = @content.to_s.strip.empty?
 
-      def current_guard_present?
-        !extract_known_guard_body(@content.to_s.strip.lines, required_guard_lines: CURRENT_GUARD_LINES).nil?
+      def current_wrapper_present?
+        !extract_current_wrapper_body(@content.to_s.strip.lines).nil?
       end
 
-      def wrapped_body = extract_existing_body&.then { |body| normalize_body(body) }
+      def normalized_body = extract_existing_body&.then { |body| normalize_body(body) }
 
       def extract_existing_body
         stripped = @content.to_s.strip
         return if stripped.empty?
 
-        return Regexp.last_match[:body] if stripped.match(LEGACY_GUARD)
+        body = extract_current_wrapper_body(stripped.lines)
+        return body if body
 
-        body = extract_known_guard_body(stripped.lines)
+        body = extract_guarded_configure_body(stripped.lines)
         return body if body
 
         body = extract_plain_configure_body(stripped.lines)
@@ -91,25 +87,25 @@ module Rails
         nil
       end
 
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-      def extract_known_guard_body(lines, required_guard_lines: nil)
-        return if lines.empty? || lines.last.strip != 'end'
+      def extract_current_wrapper_body(lines)
+        return unless lines.first&.strip == CURRENT_WRAPPER_CALL && lines.last&.strip == 'end'
 
-        configure_index = lines.index { |line| line.strip == CONFIGURE_CALL }
-        return unless configure_index
+        lines[1...-1].join.rstrip
+      end
+
+      def extract_guarded_configure_body(lines)
+        return unless guarded_configure_block?(lines)
 
-        guard_lines = lines[0...configure_index].reject { |line| line.strip.empty? }.map(&:rstrip)
-        return unless guard_lines.all? { |line| known_guard_line?(line) }
-        return if required_guard_lines && guard_lines != required_guard_lines
+        configure_index = lines.index { |line| line.strip == CONFIGURE_CALL }
+        return unless guarded_configure_lines(lines, configure_index).all? { |line| known_guard_line?(line) }
 
-        lines[configure_index...-1].join.rstrip
+        lines[(configure_index + 1)...-2].join.rstrip
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
       def extract_plain_configure_body(lines)
         return unless lines.first&.strip == CONFIGURE_CALL && lines.last&.strip == 'end'
 
-        lines.join.rstrip
+        lines[1...-1].join.rstrip
       end
 
       def known_guard_line?(line)
@@ -124,13 +120,17 @@ module Rails
         body_lines = body.rstrip.lines
         return '' if body_lines.empty?
 
-        return body.rstrip if body_lines.first.start_with?('  ')
+        minimum_indent = body_indent(body_lines)
 
-        body_lines.map { |line| line.strip.empty? ? line : "  #{line}" }.join.rstrip
+        body_lines.map do |line|
+          next line if line.strip.empty?
+
+          normalize_body_line(line, minimum_indent)
+        end.join.rstrip
       end
 
       def rebuild_content(body)
-        content = [CURRENT_GUARD_LINES.join("\n"), body, 'end'].join("\n")
+        content = [CURRENT_WRAPPER_CALL, body, 'end'].join("\n")
         @content.end_with?("\n") || @content.empty? ? "#{content}\n" : content
       end
 
@@ -142,6 +142,29 @@ module Rails
         Struct.new(:options, :conductor_workspace_root).new({ 'conductor' => false },
                                                             "File.expand_path('~/Sites/conductor/workspaces')")
       end
+
+      def guarded_configure_block?(lines)
+        lines.last(2).map(&:strip) == %w[end end] && lines.any? { |line| line.strip == CONFIGURE_CALL }
+      end
+
+      def guarded_configure_lines(lines, configure_index)
+        lines[0...configure_index].reject { |line| line.strip.empty? }.map(&:rstrip)
+      end
+
+      def body_indent(body_lines)
+        body_lines.reject { |line| line.strip.empty? }
+                  .map { |line| line[/\A\s*/].length }
+                  .min || 0
+      end
+
+      def normalize_body_line(line, minimum_indent)
+        trimmed = line.sub(/\A\s{0,#{minimum_indent}}/, '')
+        "  #{trimmed}"
+      end
+
+      def current_guard_present? = current_wrapper_present?
+
+      def wrapped_body = normalized_body
     end
     # rubocop:enable Metrics/ClassLength
   end

data/lib/rails/worktrees/post_create_runner.rb

@@ -0,0 +1,201 @@
+require 'open3'
+
+module Rails
+  module Worktrees
+    # Runs post-create setup steps in a newly created worktree.
+    # Steps run in order: credential linking, bundle install, yarn install,
+    # db:prepare (development), db:prepare (test), assets:precompile (test).
+    # rubocop:disable Metrics/ClassLength
+    class PostCreateRunner
+      STEPS = [
+        { id: :bundle, argv: %w[bundle install],
+          header: '📦 Installing gems...' },
+        { id: :yarn, argv: %w[yarn install],
+          header: '🧶 Installing JS dependencies...' },
+        { id: :db_prepare, argv: %w[bin/rails db:prepare],
+          header: '🗄️  Preparing development database...', env: { 'RAILS_ENV' => 'development' } },
+        { id: :test_db_prepare, argv: %w[bin/rails db:prepare],
+          header: '🗄️  Preparing test database...', env: { 'RAILS_ENV' => 'test' } },
+        { id: :test_assets_precompile, argv: %w[bin/rails assets:precompile],
+          header: '🎨 Precompiling test assets...', env: { 'RAILS_ENV' => 'test' } }
+      ].freeze
+
+      STEP_CONFIG = {
+        bundle: :run_bundle_install,
+        yarn: :run_yarn_install,
+        db_prepare: :run_db_prepare,
+        test_db_prepare: :run_test_db_prepare,
+        test_assets_precompile: :run_test_assets_precompile
+      }.freeze
+
+      def initialize(target_dir:, peer_roots:, configuration:, io:)
+        @target_dir    = target_dir
+        @peer_roots    = peer_roots
+        @configuration = configuration
+        @stdout        = io.fetch(:stdout)
+        @stderr        = io.fetch(:stderr)
+      end
+
+      def call(dry_run: false)
+        return 0 if @configuration.post_create_command == false
+
+        return run_custom_command(dry_run: dry_run) if custom_command?
+
+        run_built_in_steps(dry_run: dry_run)
+      end
+
+      private
+
+      def custom_command?
+        @configuration.post_create_command.is_a?(String) && !@configuration.post_create_command.empty?
+      end
+
+      def run_custom_command(dry_run:)
+        command = @configuration.post_create_command
+
+        if dry_run
+          info("Would run: #{command}")
+          return 0
+        end
+
+        info("Running: #{command}")
+        stream_shell_command(command)
+      end
+
+      def run_built_in_steps(dry_run:)
+        result = run_credential_linking(dry_run: dry_run)
+        return result unless result.zero?
+
+        STEPS.each do |step|
+          config_attr = STEP_CONFIG[step[:id]]
+          next unless @configuration.public_send(config_attr)
+          next if step[:id] == :yarn && !yarn_lock_present?
+
+          result = run_step(step, dry_run: dry_run)
+          return result unless result.zero?
+        end
+
+        0
+      end
+
+      def run_credential_linking(dry_run:)
+        # Missing peer key files are intentionally best-effort and should not abort
+        # worktree setup; the linker reports those cases in its messages while real
+        # filesystem errors still raise out of `credential_key_linker.call`.
+        return 0 unless credential_linking_enabled?
+
+        info('🔑 Linking credential keys...')
+
+        result = credential_key_linker.call(dry_run: dry_run)
+        print_credential_linking_messages(result)
+
+        0
+      end
+
+      def run_step(step, dry_run:)
+        if dry_run
+          info("Would run: #{display_command(step)}")
+          return 0
+        end
+
+        info(step[:header])
+        stream_step_command(step)
+      end
+
+      def stream_shell_command(command)
+        exit_status = capture_shell_command_exit_status(command)
+        report_failed_command(command, exit_status) unless exit_status.zero?
+        exit_status
+      end
+
+      def stream_step_command(step)
+        command = display_command(step)
+        exit_status = capture_step_command_exit_status(step)
+        report_failed_command(command, exit_status) unless exit_status.zero?
+        exit_status
+      end
+
+      def capture_shell_command_exit_status(command)
+        exit_status = nil
+
+        Open3.popen2e(base_env, command, chdir: @target_dir) do |_stdin, output, wait_thread|
+          output.each_line { |line| @stdout.print(line) }
+          exit_status = wait_thread.value.exitstatus
+        end
+
+        exit_status
+      rescue StandardError => e
+        report_failed_command_start(command, e)
+        1
+      end
+
+      def capture_step_command_exit_status(step)
+        exit_status = nil
+
+        Open3.popen2e(*step_command(step), chdir: @target_dir) do |_stdin, output, wait_thread|
+          output.each_line { |line| @stdout.print(line) }
+          exit_status = wait_thread.value.exitstatus
+        end
+
+        exit_status
+      rescue StandardError => e
+        report_failed_command_start(display_command(step), e)
+        1
+      end
+
+      def base_env
+        # Pass through only the essentials so subprocess tools work correctly.
+        ENV.to_h.slice('PATH', 'HOME', 'LANG', 'TERM', 'SHELL',
+                       'BUNDLE_GEMFILE', 'BUNDLE_PATH', 'GEM_HOME', 'GEM_PATH',
+                       'RUBY_VERSION', 'RAILS_ENV', 'NODE_ENV',
+                       'XDG_STATE_HOME', 'XDG_DATA_HOME', 'XDG_CONFIG_HOME',
+                       'DEV_PORT', 'WORKTREE_DATABASE_SUFFIX')
+      end
+
+      def yarn_lock_present?
+        File.exist?(File.join(@target_dir, 'yarn.lock'))
+      end
+
+      def display_command(step)
+        env_prefix = step.fetch(:env, {}).map { |key, value| "#{key}=#{value}" }.join(' ')
+        command = step.fetch(:argv).join(' ')
+        [env_prefix, command].reject(&:empty?).join(' ')
+      end
+
+      def step_command(step)
+        [base_env.merge(step.fetch(:env, {})), *step.fetch(:argv)]
+      end
+
+      def info(message)
+        @stdout.puts("→ #{message}")
+      end
+
+      def report_failed_command(command, exit_status)
+        @stderr.puts("❌ Command failed (exit #{exit_status}): #{command}")
+      end
+
+      def report_failed_command_start(command, error)
+        @stderr.puts("❌ Command failed to start: #{command} (#{error.message})")
+      end
+
+      def credential_linking_enabled?
+        @configuration.link_credential_keys ||
+          @configuration.link_test_credential_key ||
+          @configuration.link_production_credential_key
+      end
+
+      def credential_key_linker
+        CredentialKeyLinker.new(
+          target_dir: @target_dir,
+          peer_roots: @peer_roots,
+          configuration: @configuration
+        )
+      end
+
+      def print_credential_linking_messages(result)
+        result.messages.each { |message| info("   #{message}") }
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/rails/worktrees/project_configuration_loader.rb

@@ -0,0 +1,205 @@
+require 'pathname'
+
+module Rails
+  module Worktrees
+    # Loads project-level configuration from the generated initializer without booting the full app.
+    class ProjectConfigurationLoader
+      CURRENT_WRAPPER_CALL = 'Rails.application.config.x.rails_worktrees.tap do |config|'.freeze
+      CONFIGURE_CALL = 'Rails::Worktrees.configure do |config|'.freeze
+      INITIALIZER_RELATIVE_PATH = 'config/initializers/rails_worktrees.rb'.freeze
+      KNOWN_GUARD_FRAGMENTS = [
+        "Gem.loaded_specs.key?('rails-worktrees')",
+        'defined?(Rails::Worktrees)',
+        'Rails::Worktrees.respond_to?(:configure)'
+      ].freeze
+      TEMP_RAILS_ROOT_MUTEX = Mutex.new
+
+      def initialize(root:, configuration: Rails::Worktrees.configuration)
+        @root = root
+        @configuration = configuration
+      end
+
+      def call
+        return configuration unless initializer_path && File.file?(initializer_path)
+
+        body = extract_configuration_body(File.read(initializer_path))
+        return configuration unless body
+
+        recorder = AssignmentRecorder.new(configuration)
+
+        with_temporary_rails_root do
+          evaluate_configuration_body(body, recorder)
+        end
+
+        Rails::Worktrees.apply_application_configuration(recorder.values, configuration: configuration)
+      end
+
+      private
+
+      attr_reader :configuration, :root
+
+      def initializer_path
+        return @initializer_path if defined?(@initializer_path)
+
+        @initializer_path = project_root&.join(INITIALIZER_RELATIVE_PATH)&.to_s
+      end
+
+      def project_root
+        return @project_root if defined?(@project_root)
+
+        @project_root = discover_project_root
+      end
+
+      def discover_project_root
+        current = Pathname(root).expand_path
+
+        current.ascend do |path|
+          return path if File.file?(path.join(INITIALIZER_RELATIVE_PATH))
+        end
+
+        nil
+      end
+
+      def evaluate_configuration_body(body, recorder)
+        # Evaluates a managed initializer body like:
+        #
+        #   proc do |config|
+        #     config.branch_prefix = '🌿'
+        #   end
+        # rubocop:disable Security/Eval, Style/DocumentDynamicEvalDefinition, Style/EvalWithLocation
+        Kernel.eval(
+          "proc do |config|\n#{body.rstrip}\nend",
+          TOPLEVEL_BINDING,
+          initializer_path,
+          1
+        ).call(recorder)
+        # rubocop:enable Security/Eval, Style/DocumentDynamicEvalDefinition, Style/EvalWithLocation
+      end
+
+      def extract_configuration_body(content)
+        stripped = content.to_s.strip
+        return if stripped.empty?
+
+        lines = stripped.lines
+
+        extract_single_block_body(lines, CURRENT_WRAPPER_CALL) ||
+          extract_guarded_configure_body(lines) ||
+          extract_single_block_body(lines, CONFIGURE_CALL)
+      end
+
+      def extract_single_block_body(lines, opening_line)
+        return unless lines.first&.strip == opening_line && lines.last&.strip == 'end'
+
+        lines[1...-1].join
+      end
+
+      def extract_guarded_configure_body(lines)
+        return unless guarded_configure_block?(lines)
+
+        configure_index = lines.index { |line| line.strip == CONFIGURE_CALL }
+        return unless guarded_configure_lines(lines, configure_index).all? { |line| known_guard_line?(line) }
+
+        lines[(configure_index + 1)...-2].join
+      end
+
+      def known_guard_line?(line)
+        normalized = line.strip.delete_suffix('&&').strip.sub(/\Aif\s+/, '')
+        KNOWN_GUARD_FRAGMENTS.include?(normalized)
+      end
+
+      def guarded_configure_block?(lines)
+        lines.last(2).map(&:strip) == %w[end end] && lines.any? { |line| line.strip == CONFIGURE_CALL }
+      end
+
+      def guarded_configure_lines(lines, configure_index)
+        lines[0...configure_index].reject { |line| line.strip.empty? }.map(&:rstrip)
+      end
+
+      def with_temporary_rails_root
+        self.class::TEMP_RAILS_ROOT_MUTEX.synchronize do
+          override_state = build_rails_root_override_state
+
+          apply_temporary_rails_root(override_state, project_root)
+          yield
+        ensure
+          restore_rails_root(override_state)
+        end
+      end
+
+      def build_rails_root_override_state
+        had_root = Rails.respond_to?(:root)
+        { singleton_class: Rails.singleton_class, had_root: had_root,
+          previous_root: (Rails.method(:root) if had_root), overridden: false }
+      end
+
+      def apply_temporary_rails_root(override_state, resolved_project_root)
+        override_state[:singleton_class].send(:define_method, :root) { resolved_project_root }
+        override_state[:overridden] = true
+      end
+
+      def restore_rails_root(override_state)
+        return unless override_state
+
+        override_state[:singleton_class].send(:remove_method, :root) if override_state[:overridden]
+        return unless override_state[:had_root]
+
+        override_state[:singleton_class].send(:define_method, :root, override_state[:previous_root])
+      end
+
+      # Records config.<name> = value assignments without raising on unknown keys.
+      class AssignmentRecorder
+        attr_reader :values
+
+        def initialize(configuration = nil)
+          @configuration = configuration
+          @values = {}
+        end
+
+        def method_missing(method_name, *args)
+          name = method_name.to_s
+
+          if setter_call?(name, args)
+            values[name.delete_suffix('=').to_sym] = args.first
+          elsif getter_call?(name, args)
+            values.fetch(name.to_sym) { configuration_value_for(method_name) }
+          else
+            super
+          end
+        end
+
+        def respond_to_missing?(method_name, include_private = false)
+          name = method_name.to_s
+
+          setter_name?(name) || getter_name?(name) || super
+        end
+
+        private
+
+        attr_reader :configuration
+
+        def setter_call?(name, args)
+          setter_name?(name) && args.length == 1
+        end
+
+        def getter_call?(name, args)
+          getter_name?(name) && args.empty?
+        end
+
+        def setter_name?(name)
+          name.end_with?('=')
+        end
+
+        def getter_name?(name)
+          !setter_name?(name)
+        end
+
+        def configuration_value_for(method_name)
+          fallback_configuration = configuration
+          return unless fallback_configuration.respond_to?(method_name)
+
+          fallback_configuration.public_send(method_name)
+        end
+      end
+    end
+  end
+end

data/lib/rails/worktrees/project_maintenance.rb

@@ -151,7 +151,8 @@ module Rails
           identifier: :initializer,
           category: :install,
           relative_path: 'config/initializers/rails_worktrees.rb',
-          identical_headline: 'config/initializers/rails_worktrees.rb already uses the current safety guard.',
+          identical_headline: 'config/initializers/rails_worktrees.rb already uses the current managed initializer ' \
+                              'format.',
           fixable_headline: 'config/initializers/rails_worktrees.rb can be updated automatically.',
           warning_headline: 'config/initializers/rails_worktrees.rb needs manual review.'
         }
@@ -162,7 +163,8 @@ module Rails
             config,
             "#{config.fetch(:relative_path)} is missing.",
             updated_content: InitializerUpdater.default_content,
-            apply_messages: ['Created config/initializers/rails_worktrees.rb with the current safety guard.']
+            apply_messages: ['Created config/initializers/rails_worktrees.rb in the current managed initializer ' \
+                             'format.']
           )
         end
 

data/lib/rails/worktrees/railtie.rb

@@ -5,6 +5,10 @@ module Rails
       initializer 'rails_worktrees.installation_hint' do
         Rails::Worktrees.warn_about_missing_installation
       end
+
+      initializer 'rails_worktrees.apply_application_config', after: :load_config_initializers do |app|
+        Rails::Worktrees.apply_application_configuration(app.config.x.rails_worktrees)
+      end
     end
   end
 end

data/lib/rails/worktrees/version.rb

@@ -1,5 +1,5 @@
 module Rails
   module Worktrees
-    VERSION = '0.5.0'.freeze
+    VERSION = '0.6.0'.freeze
   end
 end

data/lib/rails/worktrees.rb

@@ -2,7 +2,10 @@ require 'pathname'
 
 require_relative 'worktrees/version'
 require_relative 'worktrees/configuration'
+require_relative 'worktrees/application_configuration'
 require_relative 'worktrees/env_bootstrapper'
+require_relative 'worktrees/credential_key_linker'
+require_relative 'worktrees/post_create_runner'
 require_relative 'worktrees/command'
 require_relative 'worktrees/cli'
 require_relative 'worktrees/browser_command'
@@ -11,6 +14,7 @@ require_relative 'worktrees/initializer_updater'
 require_relative 'worktrees/procfile_updater'
 require_relative 'worktrees/mise_toml_updater'
 require_relative 'worktrees/puma_config_updater'
+require_relative 'worktrees/project_configuration_loader'
 require_relative 'worktrees/project_maintenance'
 
 module Rails
@@ -39,6 +43,10 @@ module Rails
         @configuration = Configuration.new
       end
 
+      def apply_application_configuration(source, configuration: self.configuration)
+        ApplicationConfiguration.apply(source, configuration: configuration)
+      end
+
       def installation_complete?(root = resolve_root)
         return false unless root
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-worktrees
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Asjer Querido
@@ -55,6 +55,7 @@ files:
 - lib/generators/rails/worktrees/templates/rails_worktrees.rb.tt
 - lib/generators/worktrees/install/install_generator.rb
 - lib/rails/worktrees.rb
+- lib/rails/worktrees/application_configuration.rb
 - lib/rails/worktrees/browser_command.rb
 - lib/rails/worktrees/cli.rb
 - lib/rails/worktrees/command.rb
@@ -62,14 +63,18 @@ files:
 - lib/rails/worktrees/command/git_operations.rb
 - lib/rails/worktrees/command/name_picking.rb
 - lib/rails/worktrees/command/output.rb
+- lib/rails/worktrees/command/post_create_support.rb
 - lib/rails/worktrees/command/workspace_paths.rb
 - lib/rails/worktrees/configuration.rb
+- lib/rails/worktrees/credential_key_linker.rb
 - lib/rails/worktrees/database_config_updater.rb
 - lib/rails/worktrees/env_bootstrapper.rb
 - lib/rails/worktrees/initializer_updater.rb
 - lib/rails/worktrees/mise_toml_updater.rb
 - lib/rails/worktrees/names/cities.txt
+- lib/rails/worktrees/post_create_runner.rb
 - lib/rails/worktrees/procfile_updater.rb
+- lib/rails/worktrees/project_configuration_loader.rb
 - lib/rails/worktrees/project_maintenance.rb
 - lib/rails/worktrees/puma_config_updater.rb
 - lib/rails/worktrees/railtie.rb