easy_creds 1.0.1

data/lib/easy_creds/actions/local/status.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module EasyCreds
+  module Actions
+    module Local
+      module Status
+        def self.call(ctx)
+          env = ctx.env
+          Theme.section("Local overlay — #{env}_local")
+
+          enc_exists = ctx.io.enc_exists?(env, local: true)
+          key_exists = ctx.io.key_exists?(env, local: true)
+          gi_ok      = ctx.io.gitignore_has_local_rule?
+
+          puts ''
+          print_status_rows(env, enc_exists, key_exists, gi_ok)
+          print_key_count(ctx) if enc_exists && key_exists
+        end
+
+        private_class_method def self.print_status_rows(env, enc_exists, key_exists, gi_ok)
+          print_row("#{env}_local.yml.enc", enc_exists, presence(enc_exists))
+          print_row("#{env}_local.key    ", key_exists, presence(key_exists))
+          print_row('.gitignore rule     ', gi_ok, gi_label(gi_ok))
+        end
+
+        private_class_method def self.print_row(label, flag, value_str)
+          icon = flag ? Theme.ok(Theme::ICONS[:ok]) : Theme.warn(Theme::ICONS[:warn])
+          puts "  #{icon}  #{label}  #{value_str}"
+        end
+
+        private_class_method def self.presence(flag)
+          flag ? Theme.ok('present') : Theme.dim('absent')
+        end
+
+        private_class_method def self.gi_label(flag)
+          flag ? Theme.ok('present') : Theme.warn('missing — run init to add')
+        end
+
+        private_class_method def self.print_key_count(ctx)
+          puts ''
+          count = Flatten.dot(ctx.io.read(ctx.env, local: true)).size
+          puts "  #{Theme.dim('keys in overlay:')} #{Theme.bold(count.to_s)}"
+        rescue StandardError => e
+          puts "  #{Theme.warn('Could not read overlay:')} #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/easy_creds/actions/local/sync_key.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'tty-spinner'
+
+module EasyCreds
+  module Actions
+    module Local
+      module SyncKey
+        def self.call(ctx)
+          Theme.section("Local overlay — sync key #{ctx.env}_local")
+
+          direction = ctx.prompt.select(
+            'Sync direction:',
+            [
+              { name: "push  — upload #{ctx.env}_local.key to 1Password", value: :push },
+              { name: 'pull  — download key from 1Password', value: :pull },
+              { name: 'cancel', value: :cancel }
+            ],
+            cycle: false
+          )
+
+          return if direction == :cancel
+
+          local_field = "#{ctx.env}_local"
+          direction == :push ? push_key(ctx, local_field) : pull_key(ctx, local_field)
+        end
+
+        private_class_method def self.push_key(ctx, local_field)
+          unless ctx.io.key_exists?(ctx.env, local: true)
+            Theme.failure("#{ctx.env}_local.key not found locally. Run `init` first.")
+            return
+          end
+
+          key_val = ctx.io.key_value(ctx.env, local: true)
+          spinner = TTY::Spinner.new('[:spinner] Pushing key to 1Password...', format: :dots)
+          spinner.auto_spin
+          ok = ctx.op.write_credentials_key(local_field, key_val, ctx.config.credentials_item)
+          spinner.stop('')
+          if ok
+            Theme.success("Key pushed to op://#{ctx.config.vault}/#{ctx.config.credentials_item}/#{local_field}")
+          else
+            Theme.failure('Failed to push key — check op CLI logs')
+          end
+        end
+
+        private_class_method def self.pull_key(ctx, local_field)
+          spinner = TTY::Spinner.new('[:spinner] Pulling key from 1Password...', format: :dots)
+          spinner.auto_spin
+          remote_key = ctx.op.read_credentials_key(local_field, ctx.config.credentials_item)
+          spinner.stop('')
+
+          unless remote_key
+            Theme.failure("Key not found at op://#{ctx.config.vault}/#{ctx.config.credentials_item}/#{local_field}")
+            return
+          end
+
+          ctx.io.write_key(ctx.env, remote_key, local: true)
+          Theme.success("Key pulled to config/credentials/#{ctx.env}_local.key")
+        end
+      end
+    end
+  end
+end

data/lib/easy_creds/actions/local.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module EasyCreds
+  module Actions
+    module Local
+      def self.call(ctx)
+        loop do
+          Views::Header.render(ctx)
+          action = Views::LocalMenu.ask(ctx.prompt, ctx.env)
+
+          case action
+          when :status      then Local::Status.call(ctx)
+          when :init        then Local::Init.call(ctx)
+          when :edit        then Local::Edit.call(ctx)
+          when :editor_edit then Local::EditorEdit.call(ctx)
+          when :sync_key    then Local::SyncKey.call(ctx)
+          when :delete      then Local::Delete.call(ctx)
+          when :back        then break
+          end
+
+          next if action == :back
+
+          puts ''
+          ctx.prompt.keypress("  #{Theme.dim('Press any key to continue...')}", keys: %i[return space])
+        rescue TTY::Reader::InputInterrupt
+          break
+        end
+      end
+    end
+  end
+end

data/lib/easy_creds/actions/pull.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'tty-spinner'
+
+module EasyCreds
+  module Actions
+    module Pull
+      def self.call(ctx)
+        env = ctx.env
+        Theme.section("Pull — op://#{ctx.config.vault}/#{env} → local")
+
+        spinner = TTY::Spinner.new('[:spinner] Fetching from 1Password...', format: :dots)
+        spinner.auto_spin
+        remote_fields = ctx.op.item(env)
+        stored_key    = ctx.op.read_credentials_key(env, ctx.config.credentials_item)
+        spinner.stop('')
+
+        unless remote_fields
+          Theme.failure("No item found at op://#{ctx.config.vault}/#{env}. Run `push` or `init` first.")
+          return
+        end
+
+        remote_hash = Flatten.unflatten(remote_fields)
+        if ctx.io.enc_exists?(env)
+          pull_with_diff(ctx, env, remote_hash, remote_fields, stored_key)
+        else
+          fresh_pull(ctx, env, remote_hash, remote_fields, stored_key)
+        end
+
+        offer_key_restore(ctx, env, stored_key)
+      end
+
+      private_class_method def self.fresh_pull(ctx, env, remote_hash, remote_fields, stored_key)
+        count = remote_fields.size
+        return unless ctx.prompt.yes?("No local credentials for #{env}. Create from remote (#{count} fields)?")
+
+        ensure_key(ctx, env, stored_key)
+        ctx.io.write(env, remote_hash)
+        Theme.success("Created config/credentials/#{env}.yml.enc")
+      end
+
+      private_class_method def self.pull_with_diff(ctx, env, remote_hash, _remote_fields, stored_key)
+        local_hash = ctx.io.read(env)
+        changes    = Differ.compare(local: local_hash, remote: remote_hash)
+
+        puts ''
+        if changes.empty?
+          Theme.success('Already in sync — nothing to pull')
+          return
+        end
+
+        puts '  Changes from remote:'
+        Views::DiffTable.render(changes)
+        puts ''
+        apply_pull(ctx, changes, local_hash, remote_hash, stored_key)
+      end
+
+      private_class_method def self.apply_pull(ctx, changes, local_hash, remote_hash, stored_key)
+        env    = ctx.env
+        action = ctx.prompt.select('Apply changes?', pull_choices, cycle: false)
+        case action
+        when :apply
+          ensure_key(ctx, env, stored_key)
+          ctx.io.write(env, remote_hash)
+          Theme.success("Pulled #{Flatten.dot(remote_hash).size} field(s)")
+        when :review
+          resolved = review_changes(ctx, changes, local_hash, remote_hash)
+          ensure_key(ctx, env, stored_key)
+          ctx.io.write(env, resolved)
+          Theme.success('Pulled resolved fields')
+        when :cancel
+          Theme.notice('Pull cancelled')
+        end
+      end
+
+      private_class_method def self.pull_choices
+        [
+          { name: 'apply  — pull all changes',   value: :apply },
+          { name: 'review — resolve key by key', value: :review },
+          { name: 'cancel',                      value: :cancel }
+        ]
+      end
+
+      private_class_method def self.ensure_key(ctx, env, stored_key)
+        if stored_key && !ctx.io.key_exists?(env)
+          ctx.io.write_key(env, stored_key)
+          Theme.notice("Wrote config/credentials/#{env}.key from 1Password")
+          ensure_gitignore(ctx)
+        elsif !ctx.io.key_exists?(env)
+          ctx.io.ensure_key!(env)
+          Theme.notice("Generated new key at config/credentials/#{env}.key")
+          ensure_gitignore(ctx)
+        end
+      end
+
+      private_class_method def self.ensure_gitignore(ctx)
+        return if ctx.io.gitignore_has_rule?
+
+        ctx.io.add_gitignore_rule!
+        Theme.notice('Added /config/credentials/*.key to .gitignore')
+      end
+
+      private_class_method def self.offer_key_restore(ctx, env, stored_key)
+        return if ctx.io.key_exists?(env) || !stored_key
+
+        puts ''
+        Theme.notice('Encryption key found in 1Password but missing locally')
+        return unless ctx.prompt.yes?("Restore config/credentials/#{env}.key from 1Password?")
+
+        ctx.io.write_key(env, stored_key)
+        Theme.success('Key restored')
+        ensure_gitignore(ctx)
+      end
+
+      private_class_method def self.review_changes(ctx, changes, local_hash, remote_hash)
+        local_flat  = Flatten.dot(local_hash)
+        remote_flat = Flatten.dot(remote_hash)
+        resolved    = local_flat.dup
+
+        changes.each do |change|
+          action = prompt_change(ctx, change, local_flat, remote_flat)
+          resolved[change.key] = remote_flat[change.key] if action == :remote
+          resolved.delete(change.key) if action == :remote && remote_flat[change.key].nil?
+        end
+
+        Flatten.unflatten(resolved)
+      end
+
+      private_class_method def self.prompt_change(ctx, change, local_flat, remote_flat)
+        puts ''
+        puts "  #{Theme.bold(change.key)}  #{Theme.dim("(#{change.kind})")}"
+        puts "  #{Theme.dim('local: ')} #{local_flat[change.key]  ? '(set)' : '(missing)'}"
+        puts "  #{Theme.dim('remote:')} #{remote_flat[change.key] ? '(set)' : '(missing)'}"
+        ctx.prompt.select("Action for #{Theme.key_tag(change.key)}:", [
+                            { name: 'use remote value', value: :remote },
+                            { name: 'use local  value', value: :local },
+                            { name: 'skip (keep local)', value: :skip }
+                          ], cycle: false)
+      end
+    end
+  end
+end

data/lib/easy_creds/actions/push.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require 'tty-spinner'
+
+module EasyCreds
+  module Actions
+    module Push
+      def self.call(ctx)
+        env = ctx.env
+        Theme.section("Push — local → op://#{ctx.config.vault}/#{env}")
+
+        unless ctx.io.key_exists?(env)
+          return Theme.failure("No local key (config/credentials/#{env}.key). Run `init` or `pull` first.")
+        end
+        unless ctx.io.enc_exists?(env)
+          return Theme.failure("No local credentials (config/credentials/#{env}.yml.enc). Run `init` first.")
+        end
+
+        local_flat = Flatten.dot(ctx.io.read(env)).except(*ctx.config.ignore_keys)
+        vault_ok, item_ok = check_remote(ctx, env)
+
+        ensure_vault(ctx) unless vault_ok
+        item_ok ? update_existing(ctx, env, local_flat) : create_new(ctx, env, local_flat)
+        push_key_if_needed(ctx, env)
+      end
+
+      private_class_method def self.check_remote(ctx, env)
+        spinner = TTY::Spinner.new('[:spinner] Connecting to 1Password...', format: :dots)
+        spinner.auto_spin
+        vault_ok = ctx.op.vault_exists?
+        item_ok  = vault_ok && ctx.op.item_exists?(env)
+        spinner.stop('')
+        [vault_ok, item_ok]
+      end
+
+      private_class_method def self.ensure_vault(ctx)
+        return unless ctx.prompt.yes?("Vault #{Theme.bold(ctx.config.vault)} does not exist. Create it?")
+
+        spinner = TTY::Spinner.new('[:spinner] Creating vault...', format: :dots)
+        spinner.auto_spin
+        ctx.op.create_vault(ctx.config.vault)
+        spinner.stop('')
+        Theme.success('Vault created')
+      end
+
+      private_class_method def self.create_new(ctx, env, local_flat)
+        count = local_flat.size
+        return unless ctx.prompt.yes?("Item #{Theme.bold(env)} does not exist. Create with #{count} field(s)?")
+
+        spinner = TTY::Spinner.new('[:spinner] Creating item...', format: :dots)
+        spinner.auto_spin
+        ok = ctx.op.create_item(env, local_flat)
+        spinner.stop('')
+        ok ? Theme.success('Item created') : Theme.failure('Failed to create item.')
+      end
+
+      private_class_method def self.update_existing(ctx, env, local_flat)
+        remote_fields = ctx.op.item(env)
+        remote_hash   = Flatten.unflatten(remote_fields || {})
+        changes       = Differ.compare(local: Flatten.unflatten(local_flat), remote: remote_hash)
+
+        puts ''
+        if changes.empty?
+          Theme.success('Already in sync — nothing to push')
+          return
+        end
+
+        puts '  Changes to push:'
+        Views::DiffTable.render(changes)
+        puts ''
+        apply_push(ctx, env, local_flat, remote_fields || {}, changes)
+      end
+
+      private_class_method def self.apply_push(ctx, env, local_flat, remote_fields, changes)
+        action = ctx.prompt.select('Apply changes?', push_choices, cycle: false)
+        case action
+        when :apply
+          perform_update(ctx, env, remote_fields.merge(local_flat), 'Pushing...')
+        when :review
+          resolved = review_changes(ctx, changes, local_flat, remote_fields)
+          perform_update(ctx, env, resolved, 'Pushing resolved fields...')
+        when :cancel
+          Theme.notice('Push cancelled')
+        end
+      end
+
+      private_class_method def self.push_choices
+        [
+          { name: 'apply  — push all changes',   value: :apply },
+          { name: 'review — resolve key by key', value: :review },
+          { name: 'cancel',                      value: :cancel }
+        ]
+      end
+
+      private_class_method def self.perform_update(ctx, env, all_fields, msg)
+        spinner = TTY::Spinner.new("[:spinner] #{msg}", format: :dots)
+        spinner.auto_spin
+        ok = ctx.op.update_item(env, all_fields)
+        spinner.stop('')
+        ok ? Theme.success("Pushed #{all_fields.size} field(s)") : Theme.failure('Push failed.')
+      end
+
+      private_class_method def self.push_key_if_needed(ctx, env)
+        return unless ctx.io.key_exists?(env)
+
+        local_key  = ctx.io.key_value(env)
+        stored_key = ctx.op.read_credentials_key(env, ctx.config.credentials_item)
+        return Theme.notice('Encryption key already in sync') if stored_key == local_key
+
+        store_key(ctx, env, local_key, stored_key)
+      end
+
+      private_class_method def self.store_key(ctx, env, local_key, stored_key)
+        label     = stored_key ? 'Update' : 'Store'
+        cred_path = "op://#{ctx.config.vault}/#{ctx.config.credentials_item}/#{env}"
+        return unless ctx.prompt.yes?("#{label} encryption key in #{cred_path}?")
+
+        spinner = TTY::Spinner.new('[:spinner] Storing key...', format: :dots)
+        spinner.auto_spin
+        ok = ctx.op.write_credentials_key(env, local_key, ctx.config.credentials_item)
+        spinner.stop('')
+        ok ? Theme.success('Key stored') : Theme.failure('Key store failed')
+      end
+
+      private_class_method def self.review_changes(ctx, changes, local_flat, remote_fields)
+        resolved = remote_fields.dup
+        changes.each do |change|
+          action = prompt_change(ctx, change, local_flat, remote_fields)
+          resolved[change.key] = local_flat[change.key] if action == :local
+          resolved[change.key] = ctx.prompt.ask('New value (input hidden):') { |q| q.echo(false) } if action == :enter
+        end
+        resolved
+      end
+
+      private_class_method def self.prompt_change(ctx, change, local_flat, remote_fields)
+        puts ''
+        puts "  #{Theme.bold(change.key)}  #{Theme.dim("(#{change.kind})")}"
+        puts "  #{Theme.dim('local: ')} #{local_flat[change.key] ? '(set)' : '(missing)'}"
+        puts "  #{Theme.dim('remote:')} #{remote_fields[change.key] ? '(set)' : '(missing)'}"
+        ctx.prompt.select("Action for #{Theme.key_tag(change.key)}:", [
+                            { name: 'use local  value', value: :local },
+                            { name: 'use remote value', value: :remote },
+                            { name: 'enter new  value', value: :enter },
+                            { name: 'skip (keep as-is)', value: :skip }
+                          ], cycle: false)
+      end
+    end
+  end
+end

data/lib/easy_creds/actions/status.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'tty-spinner'
+
+module EasyCreds
+  module Actions
+    module Status
+      def self.call(ctx)
+        env = ctx.env
+        Theme.section("Status — #{env}")
+
+        local_enc = ctx.io.enc_exists?(env)
+        local_key = ctx.io.key_exists?(env)
+
+        spinner = TTY::Spinner.new('[:spinner] Checking 1Password...', format: :dots)
+        spinner.auto_spin
+        remote_fields = ctx.op.item(env)
+        key_stored    = ctx.op.read_credentials_key(env, ctx.config.credentials_item)
+        spinner.stop('')
+
+        puts ''
+        print_local_status(env, local_enc, local_key)
+        print_remote_status(ctx, env, remote_fields, key_stored)
+        print_drift(ctx, env, local_enc, local_key, remote_fields)
+        print_overlay_status(ctx, env)
+      end
+
+      private_class_method def self.print_local_status(env, local_enc, local_key)
+        print_file_row("config/credentials/#{env}.yml.enc", local_enc)
+        print_file_row("config/credentials/#{env}.key",     local_key)
+      end
+
+      private_class_method def self.print_remote_status(ctx, env, remote_fields, key_stored)
+        vault = ctx.config.vault
+        item_path = "op://#{vault}/#{env}"
+        key_path  = "op://#{vault}/#{ctx.config.credentials_item}/#{env}"
+
+        if remote_fields
+          puts "  #{Theme.ok(Theme::ICONS[:ok])}  remote  #{item_path}  #{Theme.dim("(#{remote_fields.size} fields)")}"
+        else
+          puts "  #{Theme.warn(Theme::ICONS[:warn])}  remote  #{item_path}  #{Theme.dim('(not found)')}"
+        end
+
+        if key_stored
+          puts "  #{Theme.ok(Theme::ICONS[:ok])}  key     #{key_path}  #{Theme.dim('(stored)')}"
+        else
+          puts "  #{Theme.warn(Theme::ICONS[:warn])}  key     #{key_path}  #{Theme.dim('(not stored)')}"
+        end
+      end
+
+      private_class_method def self.print_drift(ctx, env, local_enc, local_key, remote_fields)
+        puts ''
+        unless local_enc && local_key && remote_fields
+          Theme.notice('Cannot compare — missing local credentials or remote item')
+          return
+        end
+
+        local_hash = ctx.io.read(env)
+        changes    = Differ.compare(local: local_hash, remote: Flatten.unflatten(remote_fields))
+        if changes.empty?
+          Theme.success('in sync')
+        else
+          puts "  #{Theme.warn('drift:')} #{Theme.dim("(#{changes.size} change(s))")}"
+          puts ''
+          Views::DiffTable.render(changes)
+        end
+      end
+
+      private_class_method def self.print_overlay_status(ctx, env)
+        puts ''
+        overlay = ctx.io.enc_exists?(env, local: true) && ctx.io.key_exists?(env, local: true)
+        label   = overlay ? Theme.ok("present (#{env}_local.yml.enc)") : Theme.dim('absent')
+        puts "  #{Theme.dim('local overlay:')} #{label}"
+      end
+
+      private_class_method def self.print_file_row(label, exists)
+        icon = exists ? Theme.ok(Theme::ICONS[:ok]) : Theme.warn(Theme::ICONS[:warn])
+        puts "  #{icon}  local   #{label}"
+      end
+    end
+  end
+end

data/lib/easy_creds/cli.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require 'tty-prompt'
+require 'tty-screen'
+
+module EasyCreds
+  Context = Data.define(:env, :config, :op, :io, :theme, :prompt, :root)
+
+  class CLI
+    def self.start(project: nil, default_env: nil)
+      root = project&.root || detect_root
+      new(root: root, default_env: default_env).run
+    rescue Interrupt
+      puts "\n\n  #{Theme.dim('Bye!')}\n"
+      exit 0
+    end
+
+    def initialize(root:, default_env: nil)
+      @root        = Pathname.new(root)
+      @default_env = default_env
+      @config      = ConfigLoader.load(@root)
+      @io          = CredentialsIO.new(@root)
+      @prompt      = TTY::Prompt.new(interrupt: :exit, symbols: { selector: '›' })
+    end
+
+    def run
+      check_op_cli!
+
+      envs = EnvPicker.available(@root)
+      abort 'No environments found in config/environments/.' if envs.empty?
+
+      provider = build_op_client
+      env      = pick_env(envs, provider)
+      main_loop(env, provider, envs)
+    end
+
+    private
+
+    def check_op_cli!
+      return if system('which op > /dev/null 2>&1')
+
+      abort "  #{Theme.error('op CLI not found.')} Install with: brew install 1password-cli"
+    end
+
+    def build_op_client
+      vault = @config.vault || EasyCreds.config.default_vault || prompt_vault
+      op = Providers::OnePassword.new(vault: vault, log_dir: @root.join('log'))
+      until op.signed_in?
+        puts "\n  #{Theme.warn('Not signed in to 1Password.')}"
+        puts "  Run #{Theme.bold('op signin')} in another terminal, then press Enter..."
+        $stdin.gets
+      end
+      op
+    end
+
+    def prompt_vault
+      vaults = list_vaults
+      if vaults.any?
+        @prompt.select('Select vault:', vaults, cycle: true)
+      else
+        @prompt.ask('Enter vault name:')
+      end
+    end
+
+    def list_vaults
+      raw = `op vault list --format=json 2>/dev/null`
+      return [] unless $CHILD_STATUS.success?
+
+      JSON.parse(raw).map { |v| v['name'] }
+    rescue JSON::ParserError
+      []
+    end
+
+    def pick_env(envs, provider)
+      # Skip the interactive picker when a valid env was passed on the command line.
+      if @default_env && envs.include?(@default_env)
+        Views::Header.render(build_context(env: @default_env, provider: provider))
+        return @default_env
+      end
+
+      Views::Header.render(build_context(env: nil, provider: provider))
+      @prompt.select(
+        'Select environment:',
+        envs,
+        default: EnvPicker.default_index(envs, @config.default_env) + 1,
+        cycle: true
+      )
+    end
+
+    def main_loop(env, provider, envs)
+      loop do
+        ctx    = build_context(env: env, provider: provider)
+        action = render_and_pick(ctx)
+
+        case action
+        when :status     then Actions::Status.call(ctx)
+        when :push       then Actions::Push.call(ctx)
+        when :pull       then Actions::Pull.call(ctx)
+        when :init       then Actions::Init.call(ctx)
+        when :edit       then Actions::Edit.call(ctx)
+        when :editor_edit then Actions::EditorEdit.call(ctx)
+        when :local then Actions::Local.call(ctx)
+        when :switch
+          envs = EnvPicker.available(@root)
+          env  = @prompt.select('Select environment:', envs, cycle: true)
+          next
+        when :quit
+          puts "\n  #{Theme.dim('Bye!')}\n"
+          break
+        end
+
+        pause
+      end
+    end
+
+    def render_and_pick(ctx)
+      Views::Header.render(ctx)
+      Views::Menu.ask(@prompt)
+    end
+
+    def pause
+      puts ''
+      @prompt.keypress("  #{Theme.dim('Press any key to continue...')}", keys: %i[return space])
+    rescue StandardError
+      nil
+    end
+
+    def build_context(env:, provider:)
+      Context.new(
+        env: env,
+        config: @config,
+        op: provider,
+        io: @io,
+        theme: Theme,
+        prompt: @prompt,
+        root: @root
+      )
+    end
+
+    def self.detect_root
+      dir = Pathname.new(Dir.pwd)
+      dir = dir.parent until dir.root? || dir.join('config/application.rb').exist?
+      dir.root? ? Pathname.new(Dir.pwd) : dir
+    end
+    private_class_method :detect_root
+  end
+end