gitflash 0.7.0 → 0.8.0.beta1

data/lib/gitflash/commands/skill_install.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Gitflash
+  module Commands
+    # Copies the gitflash Agent Skill that ships in the gem (skills/gitflash/SKILL.md) into an
+    # agent's skills directory:
+    #   user     ~/.claude/skills/gitflash/SKILL.md, for every Claude Code session (default)
+    #   project  .claude/skills/gitflash/SKILL.md at the repository top level, shared with the team
+    #   --path   DIR/gitflash/SKILL.md, for any agent that reads skills from DIR
+    # A file that differs from the shipped one may hold the user's own edits, which no snapshot
+    # saves, so replacing it needs --confirm TOKEN instead of --yes.
+    class SkillInstall < Base
+      SOURCE = File.expand_path('../../../skills/gitflash/SKILL.md', __dir__)
+      SCOPES = %w[user project].freeze
+      NAME = 'gitflash'
+
+      def call
+        plan = build_plan
+        existing = read_existing(plan[:file])
+        return already_installed(plan) if existing == skill
+        return replace(plan, existing) if existing
+        return planned(plan, "Would install #{where(plan)}") if ui.dry_run?
+
+        install(plan, 'install')
+      end
+
+      private
+
+      def replace(plan, existing)
+        # In the plan, so the --confirm token belongs to these file contents
+        plan[:previous_sha256] = Digest::SHA256.hexdigest(existing)
+        return planned(plan, "Would update #{where(plan)}") if ui.dry_run?
+        return cancelled(plan) unless confirm_replace?(plan)
+
+        install(plan, 'update')
+      end
+
+      def install(plan, verb)
+        write(plan[:file])
+        ui.report(status: 'done', plan: plan, result: plan,
+                  text: "#{verb.capitalize}d #{where(plan)}")
+      end
+
+      def where(plan) = "the gitflash skill at #{shown(plan[:file])}"
+
+      def build_plan
+        scope, directory = target
+        { scope: scope, directory: directory, file: File.join(directory, NAME, 'SKILL.md'),
+          version: VERSION }
+      end
+
+      # The scope and the skills directory the skill goes into
+      def target
+        return path_target if options[:path]
+
+        scope = options[:scope] || 'user'
+        unless SCOPES.include?(scope)
+          usage_error!('invalid_options', "Unknown scope '#{scope}' (use #{SCOPES.join(', ')})")
+        end
+        return ['user', File.join(Dir.home, '.claude', 'skills')] if scope == 'user'
+
+        directory = File.join(repo.toplevel, '.claude', 'skills')
+        refuse_symlinks!(directory)
+        ['project', directory]
+      end
+
+      def path_target
+        usage_error!('invalid_options', 'Pass --scope or --path, not both') if options[:scope]
+
+        directory = File.expand_path(options[:path])
+        return ['path', directory] if File.directory?(directory)
+
+        usage_error!('invalid_options', "#{shown(directory)} is not a directory")
+      end
+
+      # The repository decides what .claude holds, and a link there could point at the user's own
+      # skills; writing through it would change files outside the repository
+      def refuse_symlinks!(directory)
+        paths = [File.dirname(directory), directory, File.join(directory, NAME),
+                 File.join(directory, NAME, 'SKILL.md')]
+        linked = paths.find { |path| File.symlink?(path) }
+        return unless linked
+
+        raise Error, "#{shown(linked)} is a symbolic link; gitflash will not write the skill " \
+                     'through it'
+      end
+
+      def read_existing(file)
+        File.exist?(file) ? File.read(file) : nil
+      rescue SystemCallError => e
+        raise Error, "Could not read #{shown(file)}: #{e.message}"
+      end
+
+      def confirm_replace?(plan)
+        summary = "#{shown(plan[:file])} differs from the gitflash #{VERSION} skill; " \
+                  'replacing it loses any edits made to it'
+        ui.confirm?(summary, plan: plan, irreversible: true)
+      end
+
+      def write(file)
+        AtomicFile.write(file, skill)
+      rescue SystemCallError, IOError => e
+        raise Error, "Could not write #{shown(file)}: #{e.message}"
+      end
+
+      def already_installed(plan)
+        ui.report(status: 'noop', plan: plan, result: plan,
+                  text: "The gitflash #{VERSION} skill is already at #{shown(plan[:file])}")
+      end
+
+      def skill
+        @skill ||= File.read(SOURCE)
+      end
+    end
+  end
+end

data/lib/gitflash/hook/branch_marker.rb

@@ -73,11 +73,20 @@ module Gitflash
       def stamp(creation)
         return '' unless Dir.exist?(creation[:dir])
 
+        creation_entry(creation[:dir], creation[:branch])&.join(' ').to_s
+      end
+
+      # [time, commit, message] of the oldest reflog entry of a branch, or nil. The time is the
+      # reflog entry's own (`@{UNIX}` with --date=unix), not the commit's: a branch created now
+      # from an old commit is new.
+      def creation_entry(dir, branch)
         stdout, _stderr, success = Git::BashCommand.capture(
-          'git', '-C', creation[:dir], 'log', '-g', '--format=%ct %H %gs',
-          "#{Repo::HEADS}#{creation[:branch]}", '--'
+          'git', '-C', dir, 'log', '-g', '--date=unix', '--format=%gd%x1f%H%x1f%gs',
+          "#{Repo::HEADS}#{branch}", '--'
         )
-        success ? stdout.lines(chomp: true).last.to_s : ''
+        selector, sha, subject = stdout.lines(chomp: true).last.to_s.split("\x1f", 3)
+        time = selector.to_s[/@\{(\d+)\}\z/, 1]
+        success && time ? [time.to_i, sha, subject.to_s] : nil
       end
 
       # One file per tool call, named from a hash so the id can never form a path
@@ -133,7 +142,7 @@ module Gitflash
 
         Dir.chdir(dir) do
           ownership = Ownership.new
-          next false unless created_recently?(branch) && !ownership.all.key?(branch)
+          next false unless created_recently?(dir, branch) && !ownership.all.key?(branch)
 
           ownership.mark(branch, 'agent')
           true
@@ -141,14 +150,11 @@ module Gitflash
       end
 
       # The oldest reflog entry of the branch is its creation, and it is recent
-      def created_recently?(branch)
-        stdout, _stderr, success = Git::BashCommand.capture(
-          'git', 'log', '-g', '--format=%ct%x1f%gs', "#{Repo::HEADS}#{branch}", '--'
-        )
-        return false unless success
+      def created_recently?(dir, branch)
+        time, _sha, subject = creation_entry(dir, branch)
+        return false unless time
 
-        created, subject = stdout.lines(chomp: true).last.to_s.split("\x1f", 2)
-        subject.to_s.start_with?(CREATED) && @clock.call.to_i - created.to_i <= RECENT_SECONDS
+        subject.start_with?(CREATED) && @clock.call.to_i - time <= RECENT_SECONDS
       end
     end
   end

data/lib/gitflash/hook/command_parser.rb

@@ -32,6 +32,11 @@ module Gitflash
 
       SHELLS = %w[bash sh zsh dash ksh].freeze
       MAX_NESTING = 3
+
+      # The option that makes a shell run its next argument as a script: `-c`, `-lc`. The `c` is
+      # looked for apart from the pattern, which `-ccc...c` would otherwise make backtrack.
+      def self.script_flag?(word) = word.match?(/\A-[a-z]+\z/) && word.include?('c')
+
       # Subcommands git never lets an alias replace and that have no rule, so their aliases need
       # not be read
       BUILTINS = (Rules::RULES.keys + %w[status log diff show add commit push pull fetch rev-parse
@@ -78,13 +83,14 @@ module Gitflash
 
       def git_commands(command_line, dir = @cwd, depth = 0)
         stack = []
-        ShellText.segments(command_line).flat_map do |segment|
+        ShellText.commands(command_line).flat_map do |segment, heredocs|
           words = CommandWords.new(segment)
           if DIR_COMMANDS.include?(words.words.first)
             dir = dir_after(words.words, dir, stack)
             next substituted(segment, dir, depth)
           end
-          substituted(segment, dir, depth) + in_segment(words, dir, segment.strip, depth)
+          scripts = Heredocs.scripts(heredocs, words.words)
+          substituted(segment, dir, depth, scripts) + in_segment(words, dir, segment.strip, depth)
         end
       end
 
@@ -104,9 +110,10 @@ module Gitflash
         commands_in(words.words, dir, segment, depth, words.env)
       end
 
-      # Git commands inside `$(...)`, `<(...)` and backticks, which the shell runs first
-      def substituted(command_line, dir, depth)
-        ShellText.substitutions(command_line).flat_map do |script|
+      # Git commands inside `$(...)`, `<(...)` and backticks, which the shell runs first, and in
+      # the scripts its heredocs run (Heredocs.scripts)
+      def substituted(command_line, dir, depth, scripts = [])
+        (ShellText.substitutions(command_line) + scripts).flat_map do |script|
           nested(script, dir, depth)
         end
       end
@@ -136,7 +143,7 @@ module Gitflash
         return words.drop(1).join(' ') if words.first == 'eval'
         return nil unless SHELLS.include?(File.basename(words.first))
 
-        index = words.index { |word| word.match?(/\A-[a-z]*c[a-z]*\z/) }
+        index = words.index { |word| CommandParser.script_flag?(word) }
         index && words[index + 1]
       end
 

data/lib/gitflash/hook/heredocs.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Gitflash
+  module Hook
+    # Here-documents in a shell command line (see ShellText). `cat <<'EOF'` takes the lines after
+    # the command, up to a line that is only `EOF`, as its input. Those lines are text, not
+    # commands: read as commands, an apostrophe in them would open a quote that hides the real
+    # commands after `EOF`, and a git command quoted in them would count as one that runs.
+    module Heredocs
+      # body: the lines up to the delimiter. quoted: the delimiter was quoted (`<<'EOF'`,
+      # `<<"EOF"`, `<<\EOF`), so nothing in the body runs; unquoted, `$(...)` and backticks in it
+      # run as they do inside double quotes.
+      Heredoc = Data.define(:body, :quoted)
+      # A heredoc whose body starts after the current line; part is the segment it belongs to
+      Pending = Data.define(:delimiter, :quoted, :strip_tabs, :part)
+      WORD_END = /[\s;&|<>()]/
+      BLANKS = [' ', "\t"].freeze
+
+      module_function
+
+      # [Pending, index after the delimiter] for a `<<` at index, or nil. `<<<` is a here-string,
+      # whose word is on the same line.
+      def open(line, index, part)
+        return nil unless line[index, 2] == '<<' && line[index + 2] != '<'
+
+        from = index + 2
+        strip_tabs = line[from] == '-'
+        from += 1 if strip_tabs
+        from += 1 while BLANKS.include?(line[from])
+        delimiter, quoted, to = word(line, from)
+        return nil if delimiter.empty?
+
+        [Pending.new(delimiter: delimiter, quoted: quoted, strip_tabs: strip_tabs, part: part), to]
+      end
+
+      # [the word at index without its quotes, whether it had quotes or backslashes, index after]
+      def word(line, index)
+        text = +''
+        quoted = false
+        until index >= line.length || line[index].match?(WORD_END)
+          piece, index, marked = word_piece(line, index)
+          text << piece
+          quoted ||= marked
+        end
+        [text, quoted, index]
+      end
+
+      # [text, index after it, whether it was quoted] for one quoted string, escape or character
+      def word_piece(line, index)
+        char = line[index]
+        return [line[index + 1].to_s, index + 2, true] if char == '\\'
+        return [char, index + 1, false] unless ["'", '"'].include?(char)
+
+        close = line.index(char, index + 1) || line.length
+        [line[(index + 1)...close].to_s, close + 1, true]
+      end
+
+      # The bodies of the pending heredocs, in order, read from index (the start of the next line).
+      # Returns [[part, Heredoc]...] and the index after the last body.
+      def bodies(line, index, pending)
+        found = pending.map do |doc|
+          body, index = body(line, index, doc)
+          [doc.part, Heredoc.new(body: body, quoted: doc.quoted)]
+        end
+        [found, index]
+      end
+
+      # Lines up to one that is only the delimiter (`<<-` strips leading tabs first), or to the end
+      # of the text when none is
+      def body(line, index, doc)
+        body = +''
+        while index < line.length
+          stop = line.index("\n", index) || line.length
+          text = line[index...stop]
+          index = stop + 1
+          return [body, index] if (doc.strip_tabs ? text.sub(/\A\t+/, '') : text) == doc.delimiter
+
+          body << text << "\n"
+        end
+        [body, index]
+      end
+
+      # The scripts an unquoted body runs: `$(...)` and backticks, read as inside double quotes,
+      # where a quote is a plain character
+      def substitutions(body)
+        scripts = []
+        index = 0
+        while index < body.length
+          script = ShellText.substitution(body, index, '"')
+          scripts << body[script.first...script.last] if script
+          index = script ? script.last + 1 : after(body, index)
+        end
+        scripts
+      end
+
+      def after(body, index)
+        body[index] == '\\' ? index + 2 : index + 1
+      end
+
+      # The scripts the heredocs of a command run, given the command's words: the whole body when
+      # a shell without `-c` reads it as its script (`bash <<'EOF'`, `sh -s`), else the
+      # substitutions of an unquoted body. A shell that runs a script file reads the heredoc as
+      # data instead; reading it as a script then costs at most an extra snapshot.
+      def scripts(heredocs, words)
+        reads_script = stdin_script?(words)
+        heredocs.flat_map do |heredoc|
+          next [heredoc.body] if reads_script
+          next [] if heredoc.quoted
+
+          substitutions(heredoc.body)
+        end
+      end
+
+      def stdin_script?(words)
+        CommandParser::SHELLS.include?(File.basename(words.first.to_s)) &&
+          words.none? { |word| CommandParser.script_flag?(word) }
+      end
+    end
+  end
+end

data/lib/gitflash/hook/shell_text.rb

@@ -5,14 +5,19 @@ module Gitflash
     # Reads a shell command line as text, without running it: where commands end, and which
     # commands run inside `$(...)`, `<(...)` and backticks. Quotes are followed as the shell
     # does: nothing runs inside single quotes, `$(...)` and backticks run inside double quotes,
-    # and a backslash keeps the next character (outside single quotes).
+    # and a backslash keeps the next character (outside single quotes). Heredoc bodies are taken
+    # out of the line and handed back with the command that reads them (see Heredocs).
     module ShellText
       SEPARATORS = ";&|\n"
 
+      # What one pass over a line collects. heredocs: { segment index => [Heredoc] }
+      Scan = Struct.new(:parts, :scripts, :pending, :heredocs)
+
       module_function
 
-      # The command line split on ; & | and newlines outside quotes and substitutions
-      def segments(line)
+      # The command line split on ; & | and newlines outside quotes and substitutions, as
+      # [segment, heredocs] pairs: the heredocs are the ones that segment reads
+      def commands(line)
         scan(line).first
       end
 
@@ -22,33 +27,49 @@ module Gitflash
         scan(line).last
       end
 
-      # [segments, scripts] in one pass over the line
+      # [commands, scripts] in one pass over the line
       def scan(line)
-        parts = [+'']
-        scripts = []
+        state = Scan.new([+''], [], [], {})
         index = 0
         quote = nil
-        index, quote = step(line, index, quote, parts, scripts) while index < line.length
-        [parts.reject { |part| part.strip.empty? }, scripts]
+        index, quote = step(line, index, quote, state) while index < line.length
+        commands = state.parts.each_with_index.filter_map do |part, at|
+          [part, state.heredocs.fetch(at, [])] unless part.strip.empty?
+        end
+        [commands, state.scripts]
       end
 
       # Reads what starts at index and returns where to go on, with the quote then open
-      def step(line, index, quote, parts, scripts)
+      def step(line, index, quote, state)
         char = line[index]
-        return [index + 1, close_single(char, parts)] if quote == "'"
-        return take(line, index, index + 2, parts) + [quote] if char == '\\'
+        return [index + 1, close_single(char, state.parts)] if quote == "'"
+        return take(line, index, index + 2, state.parts) + [quote] if char == '\\'
         return [comment_end(line, index), nil] if quote.nil? && comment?(line, index)
 
-        substituted(line, index, quote, parts, scripts) || plain(char, index, quote, parts)
+        opened(line, index, quote, state) || plain(line, index, quote, state)
+      end
+
+      # Takes a heredoc or a substitution that opens at index, or returns nil
+      def opened(line, index, quote, state)
+        (quote.nil? && heredoc(line, index, state)) || substituted(line, index, quote, state)
       end
 
       # Takes a substitution that opens at index, or returns nil
-      def substituted(line, index, quote, parts, scripts)
+      def substituted(line, index, quote, state)
         script = substitution(line, index, quote)
         return nil unless script
 
-        scripts << line[script.first...script.last]
-        take(line, index, script.last + 1, parts) + [quote]
+        state.scripts << line[script.first...script.last]
+        take(line, index, script.last + 1, state.parts) + [quote]
+      end
+
+      # Takes `<<WORD` at index, whose body is read after the end of this line, or returns nil
+      def heredoc(line, index, state)
+        pending, to = Heredocs.open(line, index, state.parts.length - 1)
+        return nil unless pending
+
+        state.pending << pending
+        take(line, index, to, state.parts) + [nil]
       end
 
       # A `#` that starts a word outside quotes starts a comment, which runs to the end of the
@@ -66,15 +87,27 @@ module Gitflash
         char == "'" ? nil : "'"
       end
 
-      def plain(char, index, quote, parts)
+      def plain(line, index, quote, state)
+        char = line[index]
         if !quote && SEPARATORS.include?(char)
-          parts << +''
-          return [index + 1, nil]
+          state.parts << +''
+          return [index + 1, nil] unless char == "\n" && state.pending.any?
+
+          return [bodies(line, index + 1, state), nil]
         end
-        parts.last << char
+        state.parts.last << char
         [index + 1, next_quote(char, quote)]
       end
 
+      # Reads the bodies of the heredocs opened on the line that just ended; returns the index
+      # after them
+      def bodies(line, index, state)
+        found, index = Heredocs.bodies(line, index, state.pending)
+        found.each { |part, heredoc| (state.heredocs[part] ||= []) << heredoc }
+        state.pending.clear
+        index
+      end
+
       def next_quote(char, quote)
         return (char == '"' ? nil : quote) if quote
         return char if ["'", '"'].include?(char)

data/lib/gitflash/mcp/confirmation.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'openssl'
+require 'securerandom'
+require 'time'
+
+module Gitflash
+  module Mcp
+    # The token a destructive tool hands out with its plan, and checks on the second call.
+    # It is an HMAC, under a secret that lives only in this server process, of the tool, its
+    # arguments, the plan and an expiry. So a token only confirms the exact change it was issued
+    # for, only while the repository would still get the same plan, and only for TTL seconds.
+    class Confirmation
+      TTL = 300
+
+      def initialize(secret: SecureRandom.bytes(32), clock: -> { Time.now.to_i })
+        @secret = secret
+        @clock = clock
+      end
+
+      def issue(tool, arguments, plan)
+        expires = @clock.call + TTL
+        "#{expires}.#{sign(tool, arguments, plan, expires)}"
+      end
+
+      def valid?(token, tool, arguments, plan)
+        expires, mac = token.to_s.split('.', 2)
+        return false unless expires&.match?(/\A\d+\z/) && mac
+        return false if expires.to_i < @clock.call
+
+        OpenSSL.fixed_length_secure_compare(mac, sign(tool, arguments, plan, expires.to_i))
+      rescue ArgumentError
+        false
+      end
+
+      # The envelope of a plan that waits for confirmation: the dry run's, with a new token.
+      # `token` is the one the call brought, if any, which did not fit.
+      def required(tool, arguments, preview, token)
+        note = token ? 'The confirm_token has expired or does not match this plan. ' : ''
+        new_token = issue(tool.name, arguments, preview['plan'])
+        message = "#{note}Review the plan; to make this change, call #{tool.name} with the " \
+                  "same arguments and confirm_token #{new_token} (valid until " \
+                  "#{self.class.expires_at(new_token)})."
+        preview.merge('ok' => false, 'status' => 'confirmation_required', 'dry_run' => false,
+                      'error' => { 'code' => 'confirmation_required', 'message' => message,
+                                   'exit_code' => 2, 'confirm_token' => new_token })
+      end
+
+      def self.expires_at(token)
+        Time.at(token.split('.', 2).first.to_i).utc.iso8601
+      end
+
+      private
+
+      def sign(tool, arguments, plan, expires)
+        OpenSSL::HMAC.hexdigest('SHA256', @secret, JSON.generate([tool, arguments, plan, expires]))
+      end
+    end
+  end
+end

data/lib/gitflash/mcp/elicitation.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'mcp'
+require 'timeout'
+
+module Gitflash
+  module Mcp
+    # Asks the user to approve a destructive tool's plan through the MCP client (a form with one
+    # checkbox), when the client declared the `elicitation` capability. The answer comes from the
+    # user, not the agent, so an approved plan runs without a second call.
+    #
+    # How depends on the connection. A legacy one (`initialize`) sends `elicitation/create` and
+    # waits up to TIMEOUT seconds; some clients never answer. The 2026-07-28 lifecycle forbids
+    # requests from the server, so there `ask` returns an `input_required` result holding the
+    # form, and the client calls the tool again with the answer (`answer`) and the state.
+    #
+    # Whenever the user cannot be asked, `ask` returns nil and the tool falls back to the
+    # confirm_token flow, and the reason goes to stderr.
+    class Elicitation
+      TIMEOUT = 120
+      # Accept is the approval. The box is optional and defaults to ticked: a required one made
+      # Claude Code refuse Accept until the user ticked it as well
+      SCHEMA = {
+        type: 'object',
+        properties: {
+          confirm: { type: 'boolean', title: 'Make this change', default: true,
+                     description: 'gitflash saves a snapshot first' }
+        }
+      }.freeze
+      MAX_MESSAGE = 4000
+      FORM = 'confirm'
+
+      LOG = ->(text) { warn "gitflash mcp: #{text}" }
+
+      def initialize(enabled: true, timeout: TIMEOUT, log: LOG)
+        @enabled = enabled
+        @timeout = timeout
+        @log = log
+      end
+
+      # :accepted, :declined, an `input_required` result (2026-07-28 lifecycle), or nil when the
+      # user cannot be asked. `state` gives the request state the client echoes on its retry.
+      # Without a request context (a call from Ruby, not from a client) there is nobody to ask
+      # and nothing is logged.
+      def ask(context, tool, plan, state:)
+        return unless context
+
+        reason = unavailable(context)
+        return skipped(tool, reason) if reason
+        return form(context, tool, plan, state.call) if context.modern?
+
+        direct(context, tool, plan)
+      end
+
+      # The user's answer on the retry of an `input_required` round. `fits` says whether the state
+      # the client echoed still confirms the plan the repository gives now.
+      def answer(context, tool, fits:)
+        return skipped(tool, 'the plan changed or the form expired') unless fits
+
+        response = context.input_response(FORM)
+        decision(response) || skipped(tool, "unknown answer #{response.inspect[0, 200]}")
+      end
+
+      private
+
+      def direct(context, tool, plan)
+        answer = Timeout.timeout(@timeout) do
+          context.create_form_elicitation(message: message(tool, plan), requested_schema: SCHEMA)
+        end
+        decision(answer) || skipped(tool, "unknown answer #{answer.inspect[0, 200]}")
+      rescue Timeout::Error
+        skipped(tool, "no answer within #{@timeout} seconds")
+      rescue StandardError => e
+        skipped(tool, "asking failed: #{e.class}: #{e.message}")
+      end
+
+      def form(context, tool, plan, state)
+        params = { mode: 'form', message: message(tool, plan), requestedSchema: SCHEMA }
+        result = MCP::Server::InputRequiredResult.new(
+          input_requests: { FORM => { method: 'elicitation/create', params: params } },
+          request_state: state
+        )
+        missing = result.missing_client_capabilities(context.client_capabilities)
+        missing.empty? ? result : skipped(tool, "the client cannot show forms (#{missing.to_json})")
+      end
+
+      def unavailable(context)
+        return 'started with --no-elicitation' unless @enabled
+
+        capabilities = context.client_capabilities
+        return if capabilities.is_a?(Hash) && (capabilities.key?(:elicitation) ||
+                                               capabilities.key?('elicitation'))
+
+        "the client did not declare the elicitation capability (#{capabilities.inspect[0, 200]})"
+      end
+
+      def skipped(tool, reason)
+        @log.call("#{tool.name}: not asking the user, #{reason}; using the confirm_token")
+        nil
+      end
+
+      # Accept is a yes unless the user cleared the box; decline and cancel are a no
+      def decision(answer)
+        answer = JSON.parse(JSON.generate(answer))
+        return unless answer.is_a?(Hash) && %w[accept decline cancel].include?(answer['action'])
+
+        approved = answer['action'] == 'accept' && answer.dig('content', 'confirm') != false
+        approved ? :accepted : :declined
+      end
+
+      # Branch names, paths and commit subjects come from the repository, so control characters
+      # are shown as escapes and cannot rewrite what the user reads
+      def message(tool, plan)
+        text = "gitflash #{tool.name} plans this change. A snapshot is saved first; the plan " \
+               "lists anything gitflash undo cannot bring back.\n\n" \
+               "#{TerminalText.safe(JSON.generate(plan))}"
+        text.length > MAX_MESSAGE ? "#{text[0, MAX_MESSAGE]}\n..." : text
+      end
+    end
+  end
+end