gitflash 0.5.1 → 0.7.0.beta1

data/lib/gitflash/commands/base.rb

@@ -26,6 +26,21 @@ module Gitflash
         raise Error.new("git #{command} failed:\n#{result.output}", code: 'git_failed')
       end
 
+      def config
+        @config ||= Gitflash::Config.load(root: repo.main_root)
+      end
+
+      def snapshots
+        @snapshots ||= Gitflash::Snapshots.new
+      end
+
+      # Saves the state a change is about to modify, so `gitflash undo` can restore it.
+      # `dir` saves the HEAD and files of another worktree instead of the current one.
+      def take_snapshot(reason, scope:, branches: nil, dir: nil)
+        store = dir ? Gitflash::Snapshots.new(bash: Git::InDirectory.new(dir)) : snapshots
+        store.create(reason: reason, scope: scope, branches: branches)
+      end
+
       def planned(plan, text)
         ui.report(status: 'planned', plan: plan, text: text)
       end

data/lib/gitflash/commands/branches.rb

@@ -52,6 +52,7 @@ module Gitflash
           'default' => branch.default?,
           'merged' => branch.merged && !branch.default?,
           'gone' => branch.upstream_gone?,
+          'agent' => branch.owner == 'agent',
           "ahead #{branch.ahead}" => branch.ahead.positive?,
           "behind #{branch.behind}" => branch.behind.positive?
         }.select { |_label, shown| shown }.keys.join(', ')

data/lib/gitflash/commands/checkout.rb

@@ -32,11 +32,12 @@ module Gitflash
         plan = { branch: name }
         return planned(plan, "Would check out '#{name}'") if ui.dry_run?
 
+        snapshot = take_snapshot("gitflash checkout #{name}", scope: %w[head])
         result = repo.checkout(name)
         git_error!('checkout', result) unless result.success?
 
         ui.report(status: 'done', plan: plan, result: { branch: name, previous_branch: current },
-                  text: "Switched to branch '#{name}'")
+                  undo: snapshot, text: "Switched to branch '#{name}'")
       end
 
       def noop(branch, text)

data/lib/gitflash/commands/clean.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Gitflash
+  module Commands
+    # Deletes the branches that are no longer needed: merged ones and ones whose upstream is
+    # gone by default, plus stale or agent-created ones when asked. Protected branches and
+    # branches checked out in a worktree are never selected. Unmerged branches are kept unless
+    # --force is given. Plan, confirmation, snapshot and result work as in `delete`; each chosen
+    # branch carries the reasons it was chosen.
+    class Clean < Delete
+      include CleanCriteria
+
+      def call
+        branches = repo.branches(merged_status: true)
+        select(branches)
+        return nothing_to_clean if @reasons.empty?
+
+        delete(@reasons.keys, branches.to_h { |branch| [branch.name, branch.sha] })
+      end
+
+      private
+
+      # Sets @reasons (chosen branch => why) and @skipped (matches kept for being unmerged)
+      def select(branches)
+        candidates = Cleanup.branches(branches, rules: rules, protection: protection)
+        chosen, kept = candidates.partition { |candidate| force? || candidate.item.merged }
+        @reasons = chosen.to_h { |candidate| [candidate.item.name, candidate.reasons] }
+        @skipped = kept.map { |candidate| skipped_row(candidate) }
+      end
+
+      def build_plan(names)
+        super.merge(reasons: @reasons.slice(*names), skipped: @skipped)
+      end
+
+      def skipped_row(candidate)
+        { branch: candidate.item.name, reason: 'has unmerged changes (use --force)' }
+      end
+
+      def nothing_to_clean
+        plan = { branches: [], force: force?, reasons: {}, skipped: @skipped }
+        ui.report(status: 'noop', plan: plan, result: { deleted: [], failed: [] },
+                  text: @skipped.empty? ? 'Nothing to clean' : skipped_text)
+      end
+
+      def skipped_text
+        lines = @skipped.map { |row| "Kept #{row[:branch]}: #{row[:reason]}" }
+        (['Nothing to clean.'] + lines).join("\n")
+      end
+    end
+  end
+end

data/lib/gitflash/commands/clean_criteria.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Gitflash
+  module Commands
+    # The selection options shared by `clean` and `wt clean`: --merged, --gone, --stale [DAYS]
+    # and --agent. Without any of them merged and gone branches are selected.
+    module CleanCriteria
+      FLAGS = %i[merged gone stale agent].freeze
+
+      private
+
+      def rules
+        given = FLAGS.select { |flag| options[flag] }
+        Cleanup::Rules.new(criteria: given.empty? ? Cleanup::DEFAULT_CRITERIA : given,
+                           stale_days: stale_days, now: Time.now)
+      end
+
+      def stale_days
+        value = options[:stale]
+        return config.stale_days if value.nil? || value.to_s.empty?
+
+        days = Integer(value, exception: false)
+        return days if days&.positive?
+
+        usage_error!('invalid_options', "--stale needs a positive number of days, got '#{value}'")
+      end
+    end
+  end
+end

data/lib/gitflash/commands/delete.rb

@@ -6,8 +6,6 @@ module Gitflash
     # Uses `git branch -d` (merged branches only) unless --force is given.
     # The result lists each deleted branch with its last commit, so it can be recreated.
     class Delete < Base
-      PROTECTED_NAMES = %w[main master].freeze
-
       def call(*names)
         branches = repo.branches
         candidates = branches.reject { |branch| protected?(branch) }.map(&:name)
@@ -34,8 +32,16 @@ module Gitflash
         options[:force] ? true : false
       end
 
+      def protection
+        @protection ||= Protection.new(config: config, checked_out: checked_out)
+      end
+
+      def checked_out
+        Worktrees.new(repo: repo).list.filter_map(&:branch)
+      end
+
       def protected?(branch)
-        branch.current? || branch.default? || PROTECTED_NAMES.include?(branch.name)
+        protection.protected?(branch)
       end
 
       def validate!(names, branches)
@@ -48,16 +54,24 @@ module Gitflash
 
         usage_error!('protected_branch',
                      "Refusing to delete protected branches: #{refused.join(', ')} " \
-                     '(current, default, main and master are protected)')
+                     '(current, default, main, master, `protected` in .gitflash.yml, ' \
+                     'checked out in a worktree)')
       end
 
       def delete(names, shas)
-        plan = { branches: names, force: force? }
+        plan = build_plan(names)
         return planned(plan, "Would delete:\n#{bullets(names)}") if ui.dry_run?
         return cancelled(plan) unless ui.confirm?(summary(names), plan: plan)
 
+        snapshot = take_snapshot("gitflash delete #{names.join(' ')}",
+                                 scope: %w[branches], branches: names)
         outcomes = names.map { |name| [name, repo.delete_branch(name, force: force?)] }
-        report_results(plan, outcomes, shas)
+        report_results(plan, outcomes, shas, snapshot)
+      end
+
+      # The plan reported and returned in JSON; `clean` adds why each branch was chosen
+      def build_plan(names)
+        { branches: names, force: force? }
       end
 
       def summary(names)
@@ -74,14 +88,15 @@ module Gitflash
         nil
       end
 
-      def report_results(plan, outcomes, shas)
+      def report_results(plan, outcomes, shas, snapshot)
         deleted, failed = outcomes.partition { |_name, result| result.success? }
         result = {
           deleted: deleted.map { |name, _result| { branch: name, sha: shas[name] } },
           failed: failed.map { |name, result| { branch: name, error: result.output } }
         }
         ui.report(status: failed.empty? ? 'done' : 'failed', plan: plan, result: result,
-                  error: failure(failed, outcomes), text: results_text(result))
+                  error: failure(failed, outcomes), text: results_text(result),
+                  undo: (snapshot if deleted.any?))
       end
 
       def failure(failed, outcomes)

data/lib/gitflash/commands/gc.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Gitflash
+  module Commands
+    # Deletes snapshots older than --older-than DAYS (default 30). Git frees their objects at
+    # its next garbage collection.
+    class Gc < Base
+      DEFAULT_DAYS = 30
+
+      def call
+        days = options[:older_than] || DEFAULT_DAYS
+        old = older_than(days)
+        plan = { older_than_days: days, snapshots: old.map(&:id) }
+        return nothing(plan) if old.empty?
+
+        delete(plan, "#{old.size} snapshots older than #{days} days")
+      end
+
+      private
+
+      def delete(plan, text)
+        return planned(plan, "Would delete #{text}") if ui.dry_run?
+        return cancelled(plan) unless ui.confirm?("You are about to delete #{text}", plan: plan)
+
+        plan[:snapshots].each { |id| snapshots.delete(id) }
+        ui.report(status: 'done', plan: plan, result: { deleted: plan[:snapshots] },
+                  text: "Deleted #{text}")
+      end
+
+      def older_than(days)
+        cutoff = Time.now - (days * 86_400)
+        snapshots.list.select { |snapshot| Time.iso8601(snapshot.created_at) < cutoff }
+      end
+
+      def nothing(plan)
+        ui.report(status: 'noop', plan: plan, result: { deleted: [] },
+                  text: "No snapshots older than #{plan[:older_than_days]} days")
+      end
+    end
+  end
+end

data/lib/gitflash/commands/hook_install.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Gitflash
+  module Commands
+    # Registers `gitflash hook claude` as a Claude Code hook for Bash commands: PreToolUse
+    # (snapshots before destructive git commands) and PostToolUse (marks branches an agent
+    # created). Merges into the settings file and keeps everything else in it.
+    class HookInstall < Base
+      SCOPES = Hook::Settings::SCOPES
+      MARKING_COMMAND = 'gitflash hook claude'
+
+      def call
+        plan = build_plan
+        data = settings.read(plan[:file])
+        entry = settings.entry(data)
+        marking = settings.entry(data, Hook::Claude::POST_EVENT)
+        return already_installed(plan) if up_to_date?(entry, marking, plan)
+        return planned(plan, "Would add the gitflash hook to #{plan[:file]}") if ui.dry_run?
+
+        install(data, entry, marking, plan)
+      end
+
+      private
+
+      def up_to_date?(entry, marking, plan)
+        entry && entry['command'] == plan[:command] && marking
+      end
+
+      def build_plan
+        scope = choice(:scope, SCOPES, 'local')
+        { scope: scope, file: settings.path(scope), command: hook_command,
+          marking_command: MARKING_COMMAND, applies_to: settings.applies_to(scope) }
+      end
+
+      def settings
+        @settings ||= Hook::Settings.new(options[:scope] == 'user' ? nil : repo)
+      end
+
+      def install(data, entry, marking, plan)
+        entry ? entry['command'] = plan[:command] : add_entry(data, 'PreToolUse', plan[:command])
+        add_entry(data, Hook::Claude::POST_EVENT, MARKING_COMMAND) unless marking
+        FileUtils.mkdir_p(File.dirname(plan[:file]))
+        File.write(plan[:file], "#{JSON.pretty_generate(data)}\n")
+        ui.report(status: 'done', plan: plan, result: plan,
+                  text: "Installed the gitflash hook in #{plan[:file]}.\n" \
+                        "It applies to #{plan[:applies_to]}, including running ones.")
+      end
+
+      def choice(name, allowed, default)
+        value = options[name] || default
+        return value if allowed.include?(value)
+
+        usage_error!('invalid_options', "Unknown #{name} '#{value}' (use #{allowed.join(', ')})")
+      end
+
+      def hook_command
+        mode = choice(:mode, Hook::Claude::MODES, 'snapshot')
+        mode == 'snapshot' ? 'gitflash hook claude' : "gitflash hook claude --mode #{mode}"
+      end
+
+      def already_installed(plan)
+        ui.report(status: 'noop', plan: plan, result: plan,
+                  text: "Already installed in #{plan[:file]}.\nIt applies to #{plan[:applies_to]}.")
+      end
+
+      def add_entry(data, event, command)
+        hooks = (data['hooks'] ||= {})
+        (hooks[event] ||= []) << {
+          'matcher' => 'Bash',
+          'hooks' => [{ 'type' => 'command', 'command' => command, 'timeout' => 30 }]
+        }
+      end
+    end
+  end
+end

data/lib/gitflash/commands/hook_status.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Gitflash
+  module Commands
+    # Shows whether the gitflash hook protects Claude Code sessions in the current directory:
+    # which settings files hold it, which sessions each file applies to, and whether the
+    # gitflash executable the hook runs can be found.
+    class HookStatus < Base
+      def call
+        settings = Hook::Settings.new(inside_repo? ? repo : nil)
+        files = settings.scopes.map { |scope| file_status(settings, scope) }
+        result = summary(files, find_executable)
+        ui.report(status: 'done', result: result, text: text(result))
+      end
+
+      private
+
+      def inside_repo?
+        repo.ensure_work_tree!
+        true
+      rescue Error
+        false
+      end
+
+      def summary(files, executable)
+        installed = files.select { |file| file[:installed] }
+        active = executable && installed.any?
+        { active: active ? true : false, marking: active && installed.any? { |f| f[:marking] },
+          executable: executable, files: files }
+      end
+
+      def file_status(settings, scope)
+        path = settings.path(scope)
+        data = settings.read(path)
+        entry = settings.entry(data)
+        { scope: scope, file: path, installed: !entry.nil?, command: entry&.fetch('command', nil),
+          marking: !settings.entry(data, Hook::Claude::POST_EVENT).nil?,
+          applies_to: settings.applies_to(scope) }
+      end
+
+      def find_executable
+        ENV.fetch('PATH', '').split(File::PATH_SEPARATOR).map { |dir| File.join(dir, 'gitflash') }
+           .find { |path| File.file?(path) && File.executable?(path) }
+      end
+
+      def text(result)
+        lines = [headline(result)]
+        result[:files].each do |file|
+          state = file[:installed] ? installed_text(file) : 'not installed'
+          lines << "  #{file[:scope].ljust(8)} #{file[:file]}: #{state}"
+          lines << "           applies to #{file[:applies_to]}" if file[:installed]
+        end
+        lines << "  gitflash executable: #{result[:executable] || 'not found on PATH'}"
+        lines.join("\n")
+      end
+
+      def installed_text(file)
+        note = file[:marking] ? ', marks agent branches' : ', branch marking off'
+        "installed (#{file[:command]})#{note}"
+      end
+
+      def headline(result)
+        return active_headline(result) if result[:active]
+
+        reason = if result[:executable]
+                   'run `gitflash hook install`'
+                 else
+                   'the gitflash executable is not on PATH'
+                 end
+        "gitflash hook: not active (#{reason})"
+      end
+
+      def active_headline(result)
+        return 'gitflash hook: active, marks agent branches' if result[:marking]
+
+        'gitflash hook: active (branch marking off: run `gitflash hook install` again)'
+      end
+    end
+  end
+end

data/lib/gitflash/commands/mark.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Gitflash
+  module Commands
+    # Marks branches as agent or human work (`--owner`, default agent) or removes the mark
+    # (`--clear`), so `gitflash clean --agent` knows which branches an agent created.
+    # Without branch names the current branch is marked. Needs no confirmation: only a git
+    # config key changes, and `--clear` or another `mark` reverses it.
+    class Mark < Base
+      def call(*names)
+        names = names.uniq
+        names = [current_branch!] if names.empty?
+        check_branches!(names)
+
+        previous = ownership.all
+        plan = { branches: names, owner: owner }
+        return planned(plan, "Would #{verb} #{names.join(', ')}") if ui.dry_run?
+
+        apply(plan, previous)
+      end
+
+      private
+
+      def ownership
+        @ownership ||= Ownership.new
+      end
+
+      # The owner to set, nil for --clear
+      def owner
+        given = options[:owner]
+        if options[:clear]
+          usage_error!('invalid_options', 'Use either --owner or --clear, not both') if given
+          return nil
+        end
+        return 'agent' if given.nil?
+        return given if Ownership::OWNERS.include?(given)
+
+        usage_error!('invalid_options', "Unknown owner '#{given}' (use agent or human)")
+      end
+
+      def verb
+        options[:clear] ? 'clear the mark of' : "mark as #{owner}"
+      end
+
+      def current_branch!
+        repo.current_branch || usage_error!('invalid_usage',
+                                            'HEAD is detached: pass the branch to mark')
+      end
+
+      def check_branches!(names)
+        known = repo.branches.map(&:name)
+        unknown = names.reject { |name| known.include?(name) }
+        usage_error!('unknown_branch', "Unknown branch: #{unknown.join(', ')}") if unknown.any?
+      end
+
+      def apply(plan, previous)
+        plan[:branches].each { |name| write(name, plan[:owner]) }
+        rows = plan[:branches].map { |name| row(name, plan[:owner], previous[name]) }
+        status = rows.all? { |entry| entry[:owner] == entry[:previous] } ? 'noop' : 'done'
+        ui.report(status: status, plan: plan, result: { branches: rows }, text: text(rows))
+      end
+
+      def write(name, owner)
+        owner ? ownership.mark(name, owner) : ownership.clear(name)
+      end
+
+      def row(name, owner, previous)
+        { branch: name, owner: owner, previous: previous }
+      end
+
+      def text(rows)
+        rows.map { |row| line(row) }.join("\n")
+      end
+
+      def line(row)
+        if row[:owner] == row[:previous]
+          return "#{row[:branch]} is already #{row[:owner] || 'unmarked'}"
+        end
+        return "Cleared the mark of #{row[:branch]} (was #{row[:previous]})" unless row[:owner]
+
+        "Marked #{row[:branch]} as #{row[:owner]}"
+      end
+    end
+  end
+end

data/lib/gitflash/commands/pick.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Gitflash
+  module Commands
+    # Cherry-picks commits from another branch. `--list` shows the commits of SOURCE whose change
+    # is not on the current branch yet (commits with an equivalent patch already here are marked
+    # `applied` and never picked). With SHAs, or chosen from a menu in a terminal, it applies them
+    # oldest first with `git cherry-pick -x` after saving a snapshot; `gitflash undo` returns to
+    # the starting point. On a conflict it stops and lists the files: see PickControl.
+    class Pick < Base
+      include PickOutcome
+
+      NOTHING = 'Nothing to pick: the changes are already on the current branch'
+
+      # --continue, --skip and --abort are handled by PickControl, everything else by Pick
+      def self.command_for(options)
+        PickControl::ACTIONS.any? { |action| options[action.to_sym] } ? PickControl : self
+      end
+
+      def call(source = nil, *shas)
+        usage_error!('input_required', 'Pass the source branch: gitflash pick SOURCE') unless source
+        check_idle!
+        candidates = cherry_pick.candidates(source_ref(source))
+        return list(source, candidates) if options[:list]
+
+        wanted = shas.empty? ? pick_from_menu(candidates) : shas
+        return 0 if wanted.nil?
+
+        pick(source, select_candidates(source, candidates, wanted))
+      end
+
+      private
+
+      def check_idle!
+        return unless cherry_pick.in_progress?
+
+        usage_error!('invalid_usage', 'A cherry-pick is already in progress: use gitflash pick ' \
+                                      '--continue, --skip or --abort')
+      end
+
+      def source_ref(source)
+        ref = cherry_pick.source_ref(source)
+        ref || usage_error!('unknown_branch', "Unknown branch '#{source}'")
+      end
+
+      def list(source, candidates)
+        ui.report(status: 'done', result: { source: source, commits: candidates.map(&:to_h) },
+                  text: table(candidates))
+      end
+
+      def table(candidates)
+        return 'No commits to pick.' if candidates.empty?
+
+        candidates.map { |candidate| row(candidate) }.join("\n")
+      end
+
+      def row(candidate)
+        stat = "+#{candidate.insertions} -#{candidate.deletions}"
+        "#{candidate.applied ? '=' : ' '} #{candidate.short_sha}  " \
+          "#{TerminalText.safe(candidate.subject)}  (#{TerminalText.safe(candidate.author)}, " \
+          "#{candidate.date[0, 10]}, #{candidate.files} files #{stat})"
+      end
+
+      # SHAs picked from a menu, nil after telling the user there is nothing to pick
+      def pick_from_menu(candidates)
+        require_interactive!('Pass the commits to pick: gitflash pick SOURCE SHA...')
+        fresh = candidates.reject(&:applied)
+        return nothing_chosen('No commits to pick') if fresh.empty?
+
+        chosen = ui.multi_select('Select commits to pick (oldest first)',
+                                 fresh.to_h { |candidate| [row(candidate), candidate.sha] })
+        chosen.empty? ? nothing_chosen('No commits selected') : chosen
+      end
+
+      def nothing_chosen(text)
+        report_nothing(text)
+        nil
+      end
+
+      # The asked-for commits in source order (oldest first), whatever order they were given in
+      def select_candidates(source, candidates, wanted)
+        found = wanted.map { |arg| find(arg, candidates, source) }
+        candidates.select { |candidate| found.include?(candidate) }
+      end
+
+      def find(arg, candidates, source)
+        matches = candidates.select { |candidate| candidate.sha.start_with?(arg.to_s) }
+        return matches.first if arg.to_s.length >= 4 && matches.size == 1
+
+        usage_error!('unknown_commit', "'#{arg}' is not a commit of #{source} that is missing " \
+                                       'from the current branch (or it is ambiguous)')
+      end
+
+      def pick(source, chosen)
+        fresh, applied = chosen.partition { |candidate| !candidate.applied }
+        return report_nothing(NOTHING) if fresh.empty?
+
+        plan = build_plan(source, fresh, applied)
+        return planned(plan, "Would pick:\n#{bullets(plan)}") if ui.dry_run?
+        return cancelled(plan) unless confirm?(plan)
+
+        run(plan)
+      end
+
+      def build_plan(source, fresh, applied)
+        skipped = applied.map { |c| { sha: c.sha, reason: 'already on the current branch' } }
+        { source: source, commits: fresh.map(&:sha), skipped: skipped,
+          commit: options[:commit] != false }
+      end
+
+      def confirm?(plan)
+        ui.confirm?("You are about to pick:\n\n#{bullets(plan)}", plan: plan)
+      end
+
+      def run(plan)
+        snapshot = take_snapshot("gitflash pick #{plan[:source]}",
+                                 scope: %w[branches head worktree], branches: current_branch_names)
+        result = cherry_pick.apply(plan[:commits], commit: plan[:commit])
+        outcome(plan, result, plan[:commits], snapshot)
+      end
+
+      def bullets(plan)
+        plan[:commits].map { |sha| "* #{sha[0, 7]}" }.join("\n")
+      end
+
+      def report_nothing(text)
+        ui.report(status: 'noop', result: { applied: [] }, text: text)
+      end
+    end
+  end
+end

data/lib/gitflash/commands/pick_control.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Gitflash
+  module Commands
+    # `gitflash pick --continue`, `--skip` or `--abort`: wraps git's own cherry-pick controls for
+    # a pick that stopped on conflicts. --skip and --abort discard work in progress, so they ask
+    # for confirmation and save a snapshot first; --continue adds to the work and does not.
+    class PickControl < Base
+      include PickOutcome
+
+      ACTIONS = %w[continue skip abort].freeze
+
+      def call(*)
+        action = chosen_action
+        usage_error!('invalid_usage', 'No cherry-pick in progress') unless cherry_pick.in_progress?
+
+        plan = build_plan(action)
+        return perform(action, plan, nil) if action == 'continue'
+        return planned(plan, "Would #{action} the cherry-pick in progress") if ui.dry_run?
+        return cancelled(plan) unless ui.confirm?(summary(action), plan: plan)
+
+        perform(action, plan, take_snapshot("gitflash pick --#{action}", scope: %w[head worktree]))
+      end
+
+      private
+
+      def chosen_action
+        given = ACTIONS.select { |action| options[action.to_sym] }
+        return given.first if given.one?
+
+        usage_error!('invalid_options', 'Use exactly one of --continue, --skip or --abort')
+      end
+
+      def build_plan(action)
+        progress = cherry_pick.progress
+        { action: action, current: progress.current, conflicted: progress.conflicted,
+          remaining: progress.remaining }
+      end
+
+      def summary(action)
+        "You are about to #{action} the cherry-pick in progress; " \
+          'the conflict resolution made so far is discarded.'
+      end
+
+      def perform(action, plan, snapshot)
+        result = cherry_pick.public_send(action == 'continue' ? :continue : action.to_sym)
+        return outcome_after(action, plan, result, snapshot) if action != 'abort'
+
+        git_error!('cherry-pick --abort', result) unless result.success?
+        finish(action, plan, snapshot)
+      end
+
+      def outcome_after(action, plan, result, snapshot)
+        return conflict(plan, result, [], snapshot) if cherry_pick.in_progress?
+
+        git_error!("cherry-pick --#{action}", result) unless result.success?
+        finish(action, plan, snapshot)
+      end
+
+      def finish(action, plan, snapshot)
+        head = repo.resolve_commit('HEAD')
+        ui.report(status: 'done', plan: plan, result: { action: action, head: head },
+                  undo: snapshot, text: "Cherry-pick #{action} done, now at #{head[0, 7]}")
+      end
+    end
+  end
+end