gitflash 0.7.0 → 0.8.0.beta1

data/lib/gitflash/mcp/plan_change.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'json_schemer'
+
+module Gitflash
+  module Mcp
+    # The plan_change tool: the dry run of a destructive tool and a confirm_token for it, as a
+    # read-only call. The client has only checked that `arguments` is an object, so they are
+    # checked against the target tool's schema here.
+    class PlanChange
+      def initialize(runner, confirmation)
+        @runner = runner
+        @confirmation = confirmation
+      end
+
+      def call(arguments)
+        target = Tools::ALL.find { |tool| tool.kind == :destructive && tool.name == arguments[:tool] }
+        return invalid("Unknown destructive tool #{arguments[:tool].inspect}") unless target
+
+        check(target, JSON.parse(JSON.generate(arguments[:arguments] || {})))
+      end
+
+      private
+
+      def check(target, arguments)
+        problems = problems(target, arguments)
+        return plan(target, arguments.transform_keys(&:to_sym).sort.to_h) if problems.empty?
+
+        invalid("Invalid arguments for #{target.name}: #{problems.join('; ')}")
+      end
+
+      def plan(target, arguments)
+        preview = @runner.call([*target.argv.call(arguments), '--dry-run'])
+        return preview unless preview['status'] == 'planned'
+
+        @confirmation.required(target, arguments, preview, nil)
+      end
+
+      def problems(target, arguments)
+        JSONSchemer.schema(Tools.input_schema(target)).validate(arguments).map do |problem|
+          problem['error']
+        end
+      end
+
+      def invalid(message)
+        { 'schema' => Ui::JSON_SCHEMA_VERSION, 'command' => 'gitflash', 'ok' => false,
+          'status' => 'error', 'dry_run' => false,
+          'error' => { 'code' => 'invalid_options', 'message' => message, 'exit_code' => 2 } }
+      end
+    end
+  end
+end

data/lib/gitflash/mcp/runner.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'open3'
+
+module Gitflash
+  module Mcp
+    # Runs one gitflash command with --json in a child process and returns its envelope.
+    # A child process keeps the MCP connection safe: commands print to stdout, which is the
+    # stdio transport here, and an error in a command can never take the server down. The child
+    # runs this same copy of gitflash, in the server's working directory, without a terminal,
+    # so it never waits for input.
+    class Runner
+      LIB = File.expand_path('../..', __dir__)
+      BIN = File.expand_path('../../../bin/gitflash', __dir__)
+
+      def initialize(dir: Dir.pwd)
+        @dir = dir
+      end
+
+      def call(argv)
+        stdout, stderr, status = Open3.capture3(Gem.ruby, '-I', LIB, BIN, *argv, '--json',
+                                                chdir: @dir, stdin_data: '')
+        JSON.parse(stdout)
+      rescue JSON::ParserError
+        failed(argv, status, stderr)
+      end
+
+      private
+
+      # A command that printed no envelope, which only happens when gitflash itself breaks
+      def failed(argv, status, stderr)
+        message = "gitflash #{argv.first} printed no JSON (exit #{status&.exitstatus}): " \
+                  "#{stderr.to_s.strip[0, 2000]}"
+        { 'schema' => Ui::JSON_SCHEMA_VERSION, 'command' => argv.first, 'ok' => false,
+          'status' => 'error', 'dry_run' => false,
+          'error' => { 'code' => 'failed', 'message' => message, 'exit_code' => 1 } }
+      end
+    end
+  end
+end

data/lib/gitflash/mcp/server.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'mcp'
+
+module Gitflash
+  module Mcp
+    # `gitflash mcp`: an MCP server on stdio for the repository in its working directory.
+    # Every tool runs a gitflash command (Runner) and answers with its JSON v1 envelope, so the
+    # tools and the CLI share one contract. A destructive tool first asks the user to approve its
+    # plan through the client (Elicitation). When the client cannot ask, it takes two calls: the
+    # first returns the plan with status `confirmation_required` and `error.confirm_token`, the
+    # second passes that token as `confirm_token` and makes exactly that change (Confirmation).
+    class Server
+      INSTRUCTIONS = <<~TEXT
+        gitflash works on the git repository this server was started in. Every result is the
+        gitflash JSON envelope (`gitflash schema` describes it): check `ok`, `status` and
+        `error.code`. Changes save a snapshot first; keep `undo.command` and tell the user how to
+        undo. To see what a destructive tool would do, call plan_change (read-only); it returns
+        the plan and a confirm_token. Destructive tools ask the user to approve the plan when
+        the client supports
+        elicitation, unless called with a confirm_token; status `cancelled` means the user
+        declined, so do not retry. Otherwise they answer the first call with the plan, status
+        `confirmation_required` and `error.confirm_token`: show the plan to the user, and only
+        when it is what they asked for, call the tool again with the same arguments and
+        `confirm_token`. A token expires after 5 minutes and only confirms that plan.
+        clean_branches selects branches by rule: unless the user approved its plan in the client,
+        show them the list and wait for their OK. Do not call save_snapshot before plain git
+        commands when the gitflash hook is installed; the hook saves one itself.
+      TEXT
+
+      ANNOTATIONS = {
+        read: { read_only_hint: true, destructive_hint: false, idempotent_hint: true },
+        additive: { read_only_hint: false, destructive_hint: false, idempotent_hint: false },
+        destructive: { read_only_hint: false, destructive_hint: true, idempotent_hint: false },
+        plan: { read_only_hint: true, destructive_hint: false, idempotent_hint: false }
+      }.freeze
+
+      CONFIRM_TOKEN = { type: 'string',
+                        description: 'The error.confirm_token of plan_change or of the first ' \
+                                     'call, to make the change it planned' }.freeze
+
+      def initialize(runner: Runner.new, confirmation: Confirmation.new,
+                     elicitation: Elicitation.new)
+        @runner = runner
+        @confirmation = confirmation
+        @elicitation = elicitation
+      end
+
+      def start
+        MCP::Server::Transports::StdioTransport.new(mcp_server).open
+      end
+
+      def mcp_server
+        MCP::Server.new(name: 'gitflash', version: VERSION, instructions: INSTRUCTIONS,
+                        tools: Tools::ALL.map { |tool| mcp_tool(tool) })
+      end
+
+      # The envelope a tool answers with. `context` is the MCP server context of the request,
+      # through which the user can be asked.
+      def call(tool, arguments, context = nil)
+        arguments = arguments.transform_keys(&:to_sym)
+        return destructive(tool, arguments, context) if tool.kind == :destructive
+        return PlanChange.new(@runner, @confirmation).call(arguments) if tool.kind == :plan
+
+        @runner.call(tool.argv.call(arguments))
+      end
+
+      private
+
+      def mcp_tool(tool)
+        server = self
+        schema = Tools.input_schema(tool)
+        schema['properties']['confirm_token'] = CONFIRM_TOKEN if tool.kind == :destructive
+        MCP::Tool.define(
+          name: tool.name, description: tool.description, input_schema: schema,
+          annotations: ANNOTATIONS.fetch(tool.kind).merge(open_world_hint: false)
+        ) do |server_context: nil, **arguments|
+          result = server.call(tool, arguments, server_context)
+          result.is_a?(Hash) ? server.send(:respond, result) : result
+        end
+      end
+
+      def respond(envelope)
+        MCP::Tool::Response.new([{ type: 'text', text: JSON.generate(envelope) }],
+                                structured_content: envelope,
+                                error: %w[error failed].include?(envelope['status']))
+      end
+
+      # The dry run gives the plan. A valid token for it, or the user's approval, makes the
+      # change; a declined plan is cancelled; otherwise the plan is returned with a new token.
+      # Nothing to do or an error is returned as it is.
+      def destructive(tool, arguments, context)
+        token = arguments.delete(:confirm_token)
+        arguments = arguments.sort.to_h
+        argv = tool.argv.call(arguments)
+        preview = @runner.call([*argv, '--dry-run'])
+        return preview unless preview['status'] == 'planned'
+
+        plan = preview['plan']
+        return run(argv, plan) if token && @confirmation.valid?(token, tool.name, arguments, plan)
+
+        approve(tool, arguments, preview, token, context)
+      end
+
+      # A token that does not fit gets a new one without asking: the agent asked for this change
+      # before, so the user is not asked twice
+      def approve(tool, arguments, preview, token, context)
+        answer = elicited(tool, arguments, preview['plan'], context) unless token
+        return answer if answer.is_a?(MCP::Server::InputRequiredResult)
+        return run(tool.argv.call(arguments), preview['plan']) if answer == :accepted
+        return declined(preview) if answer == :declined
+
+        @confirmation.required(tool, arguments, preview, token)
+      end
+
+      # The form's request state is a token signed for `form:TOOL`, so the client's echo binds the
+      # answer to this plan and expires like a confirm_token, and it cannot be passed off as a
+      # confirm_token itself
+      def elicited(tool, arguments, plan, context)
+        name = "form:#{tool.name}"
+        state = context.request_state if context.respond_to?(:request_state)
+        unless state
+          issue = -> { @confirmation.issue(name, arguments, plan) }
+          return @elicitation.ask(context, tool, plan, state: issue)
+        end
+
+        @elicitation.answer(context, tool, fits: @confirmation.valid?(state, name, arguments, plan))
+      end
+
+      def declined(preview)
+        preview.merge('status' => 'cancelled', 'dry_run' => false)
+      end
+
+      # --yes covers changes undo can revert. A change it cannot revert (removing a worktree with
+      # ignored files) asks for the command's own token; the MCP token confirmed the same plan,
+      # so it is passed on, but only when the command still plans exactly that.
+      def run(argv, plan)
+        result = @runner.call([*argv, '--yes'])
+        cli_token = result.dig('error', 'confirm_token')
+        return result unless result['status'] == 'confirmation_required' && cli_token
+        return result unless result['plan'] == plan
+
+        @runner.call([*argv, '--confirm', cli_token])
+      end
+    end
+  end
+end

data/lib/gitflash/mcp/tools.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Gitflash
+  module Mcp
+    # The tools `gitflash mcp` offers. Each one is a gitflash command; `argv` turns the tool's
+    # arguments into that command's words. The kind decides how it runs (see Server):
+    #   read         reads only
+    #   additive     changes the repository in a way that loses nothing; runs at once
+    #   destructive  can discard work; the first call returns the plan and a confirm_token,
+    #                a second call with the token makes the change. A snapshot is always
+    #                saved first, so `undo` can bring it back.
+    #   plan         plan_change: the plan and token of a destructive tool, as a read-only tool,
+    #                so a client that asks before every destructive call asks only once
+    module Tools
+      Tool = Data.define(:name, :kind, :description, :properties, :required, :argv)
+
+      # Names, SHAs and paths become command words, so one that starts with a dash could turn
+      # into an option
+      NAME = { type: 'string', minLength: 1, pattern: '^[^-]' }.freeze
+      NAMES = { type: 'array', items: NAME, minItems: 1 }.freeze
+      DAYS = { type: 'integer', minimum: 1 }.freeze
+
+      # --merged, --gone, --stale DAYS, ... from the boolean and number arguments that are set
+      def self.flags(args, *names)
+        names.flat_map do |name|
+          value = args[name]
+          flag = "--#{name.to_s.delete_suffix('_days').tr('_', '-')}"
+          if value.is_a?(Integer) then [flag, value.to_s]
+          elsif value == true then [flag]
+          else []
+          end
+        end
+      end
+
+      FILTERS = {
+        merged: { type: 'boolean', description: 'Branches merged into the default branch' },
+        gone: { type: 'boolean', description: 'Branches whose upstream branch was deleted' },
+        stale_days: DAYS.merge(description: 'Branches without commits for this many days')
+      }.freeze
+
+      COMMANDS = [
+        Tool.new(
+          name: 'list_branches', kind: :read,
+          description: 'List local branches with last commit, upstream (ahead, behind, gone), ' \
+                       'merge status and owner (agent or human). A branch is listed when it ' \
+                       'matches any filter given.',
+          properties: FILTERS, required: [],
+          argv: ->(a) { ['branches', *flags(a, :merged, :gone, :stale_days)] }
+        ),
+        Tool.new(
+          name: 'list_worktrees', kind: :read,
+          description: 'List worktrees with absolute path, branch, HEAD, dirty state, ' \
+                       'ahead/behind, merge status, lock state and owner.',
+          properties: {}, required: [], argv: ->(_) { %w[worktree list] }
+        ),
+        Tool.new(
+          name: 'list_pickable_commits', kind: :read,
+          description: 'List the commits of a source branch that are not on the current branch ' \
+                       'yet. Commits whose patch is already here are marked.',
+          properties: { source: NAME.merge(description: 'Branch to pick from') },
+          required: %w[source], argv: ->(a) { ['pick', a[:source], '--list'] }
+        ),
+        Tool.new(
+          name: 'list_snapshots', kind: :read,
+          description: 'List the snapshots gitflash saved before changes, newest first.',
+          properties: {}, required: [], argv: ->(_) { %w[snapshots] }
+        ),
+        Tool.new(
+          name: 'add_worktree', kind: :additive,
+          description: 'Add a worktree for a branch: an existing local branch, a branch that ' \
+                       'only exists on origin, or a new branch (from HEAD or `from`). New ' \
+                       'branches are marked as agent work. The result holds the absolute path.',
+          properties: { branch: NAME, from: NAME.merge(description: 'Start a new branch here'),
+                        path: NAME.merge(description: 'Directory (default from worktree_dir)') },
+          required: %w[branch],
+          argv: lambda { |a|
+            ['worktree', 'add', a[:branch], *(a[:from] ? ['--from', a[:from]] : []),
+             *(a[:path] ? ['--path', a[:path]] : [])]
+          }
+        ),
+        Tool.new(
+          name: 'cherry_pick_commits', kind: :additive,
+          description: 'Apply commits of a source branch to the current branch, oldest first, ' \
+                       'with `git cherry-pick -x`, after a snapshot. On a conflict it stops with ' \
+                       'error code `conflict` and lists the files; then use cherry_pick_control.',
+          properties: { source: NAME, shas: NAMES,
+                        commit: { type: 'boolean',
+                                  description: 'false only stages the changes (default true)' } },
+          required: %w[source shas],
+          argv: lambda { |a|
+            ['pick', a[:source], *a[:shas], '--yes', *(a[:commit] == false ? ['--no-commit'] : [])]
+          }
+        ),
+        Tool.new(
+          name: 'cherry_pick_control', kind: :additive,
+          description: 'Continue a stopped pick after resolving its conflicts, skip the commit ' \
+                       'that conflicts, or abort and return to the state before the pick.',
+          properties: { action: { enum: %w[continue skip abort] } }, required: %w[action],
+          argv: ->(a) { ['pick', "--#{a[:action]}", '--yes'] }
+        ),
+        Tool.new(
+          name: 'mark_branches', kind: :additive,
+          description: 'Mark branches as agent or human work (or clear the mark), so ' \
+                       'clean_branches with `agent` can find agent branches.',
+          properties: { branches: NAMES, owner: { enum: Ownership::OWNERS },
+                        clear: { type: 'boolean' } },
+          required: %w[branches],
+          argv: lambda { |a|
+            ['mark', *a[:branches], *(a[:clear] ? ['--clear'] : ['--owner', a[:owner] || 'agent'])]
+          }
+        ),
+        Tool.new(
+          name: 'save_snapshot', kind: :additive,
+          description: 'Save the current branches, HEAD, files and stashes, so undo can come ' \
+                       'back here. Not needed before plain git commands when the gitflash ' \
+                       'hook is installed: it saves a snapshot itself.',
+          properties: { message: { type: 'string', description: 'Why the snapshot is taken' } },
+          required: [],
+          argv: ->(a) { ['snapshot', *(a[:message] ? ['--message', a[:message]] : [])] }
+        ),
+        Tool.new(
+          name: 'delete_branches', kind: :destructive,
+          description: 'Delete local branches. Protected branches are never deleted; unmerged ' \
+                       'ones only with `force`.',
+          properties: { branches: NAMES, force: { type: 'boolean' } }, required: %w[branches],
+          argv: ->(a) { ['delete', *a[:branches], *flags(a, :force)] }
+        ),
+        Tool.new(
+          name: 'clean_branches', kind: :destructive,
+          description: 'Delete merged branches and branches whose upstream is gone, and with ' \
+                       '`stale_days` or `agent` also stale or agent-created ones. Unmerged ones ' \
+                       'only with `force`. Protected branches are never deleted.',
+          properties: FILTERS.merge(agent: { type: 'boolean', description: 'Agent branches' },
+                                    force: { type: 'boolean' }),
+          required: [],
+          argv: ->(a) { ['clean', *flags(a, :merged, :gone, :stale_days, :agent, :force)] }
+        ),
+        Tool.new(
+          name: 'reset_branch', kind: :destructive,
+          description: 'Reset the current branch to a commit: mixed (default) keeps changes ' \
+                       'unstaged, soft keeps them staged, hard discards them.',
+          properties: { commit: NAME, mode: { enum: %w[mixed soft hard] } }, required: %w[commit],
+          argv: lambda { |a|
+            ['reset', a[:commit], *(%w[soft hard].include?(a[:mode]) ? ["--#{a[:mode]}"] : [])]
+          }
+        ),
+        Tool.new(
+          name: 'remove_worktrees', kind: :destructive,
+          description: 'Remove worktrees, given as paths or branch names. Dirty or locked ones ' \
+                       'only with `force`. Ignored files in them are deleted and no snapshot ' \
+                       'saves them: the plan lists them.',
+          properties: { worktrees: NAMES, force: { type: 'boolean' } }, required: %w[worktrees],
+          argv: ->(a) { ['worktree', 'remove', *a[:worktrees], *flags(a, :force)] }
+        ),
+        Tool.new(
+          name: 'move_worktree', kind: :destructive,
+          description: 'Move a worktree (path or branch name) to another directory.',
+          properties: { worktree: NAME, path: NAME, force: { type: 'boolean' } },
+          required: %w[worktree path],
+          argv: ->(a) { ['worktree', 'move', a[:worktree], a[:path], *flags(a, :force)] }
+        ),
+        Tool.new(
+          name: 'undo', kind: :destructive,
+          description: 'Restore a snapshot: by default the latest one taken in this worktree. ' \
+                       'The current state is saved first, so an undo can be undone.',
+          properties: { snapshot: NAME.merge(description: 'Snapshot id from a result or ' \
+                                                          'list_snapshots') },
+          required: [], argv: ->(a) { ['undo', *[a[:snapshot]].compact] }
+        )
+      ].freeze
+
+      PLAN = Tool.new(
+        name: 'plan_change', kind: :plan,
+        description: 'Show what a destructive tool would do, without changing anything: returns ' \
+                     'its plan with status confirmation_required and error.confirm_token. Then ' \
+                     'call that tool with the same arguments and confirm_token to make the change.',
+        properties: {
+          tool: { enum: COMMANDS.select { |tool| tool.kind == :destructive }.map(&:name) },
+          arguments: { type: 'object', description: "The destructive tool's arguments" }
+        },
+        required: %w[tool arguments], argv: nil
+      )
+
+      ALL = [*COMMANDS, PLAN].freeze
+
+      # The JSON Schema of a tool's arguments, with string keys
+      def self.input_schema(tool)
+        JSON.parse(JSON.generate({ type: 'object', properties: tool.properties,
+                                   required: tool.required, additionalProperties: false }))
+      end
+    end
+  end
+end

data/lib/gitflash/repo.rb

@@ -26,11 +26,12 @@ module Gitflash
       raise Error.new('Not a git repository', code: 'not_a_repository')
     end
 
-    # Local branches. With `merged_status: true` each branch also reports whether it is
-    # merged into the default branch (one extra git call).
+    # Local branches. With `merged_status: true` each branch also reports whether it is merged
+    # into the default branch and what its reflog says (BranchActivity): two extra git calls.
     def branches(merged_status: false)
       merged_names = merged_status ? merged_branch_names : nil
       list = branch_lines.map { |line| Branch.parse(line, default_branch:, merged_names:) }
+      list = BranchActivity.annotate(list, bash: @bash) if merged_status
       Ownership.new(bash: @bash).annotate(list)
     end
 
@@ -104,8 +105,7 @@ module Gitflash
     end
 
     def branch_lines
-      @branch_lines ||= @bash.exec('git', 'for-each-ref', "--format=#{BRANCH_FORMAT}",
-                                   HEADS)
+      @branch_lines ||= @bash.exec('git', 'for-each-ref', "--format=#{BRANCH_FORMAT}", HEADS)
                              .each_line(chomp: true).reject(&:empty?)
     end
 

data/lib/gitflash/reused_snapshot.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+module Gitflash
+  # A snapshot `Snapshots#create` handed back because the state had not changed since it was
+  # taken. Output says so, so its older id is not mistaken for a missing snapshot.
+  class ReusedSnapshot < SimpleDelegator
+    def reused? = true
+  end
+end

data/lib/gitflash/skill_cli.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'thor'
+
+module Gitflash
+  # `gitflash skill ...`: the Agent Skill that tells agents how to use gitflash
+  class SkillCli < Thor
+    include CommandRunner
+
+    namespace 'skill'
+
+    def self.exit_on_failure?
+      true
+    end
+
+    desc 'install', 'Copy the gitflash Agent Skill into an agent skills directory'
+    long_desc <<~TEXT
+      Copies SKILL.md, which explains to agents when to use gitflash, the --json envelope, the
+      plan then --yes flow and undo, into a skills directory:
+
+      --scope user     ~/.claude/skills/gitflash/SKILL.md (default); every Claude Code session
+      --scope project  .claude/skills/gitflash/SKILL.md at the repository top level, to commit
+                       and share with your team
+      --path DIR       DIR/gitflash/SKILL.md, for any agent that reads skills from DIR
+
+      Does nothing when the installed skill is the one of this version. Run it again after
+      upgrading gitflash. A file that differs may hold your own edits, which gitflash undo cannot
+      bring back: replacing it needs --confirm TOKEN (the token the refusal names), or typing the
+      token in a terminal.
+
+      Accepts the global --json and --dry-run options after the subcommand: gitflash skill install --json
+    TEXT
+    option :scope, type: :string, enum: Commands::SkillInstall::SCOPES,
+                   desc: 'user or project (default: user)'
+    option :path, type: :string, banner: 'DIR', desc: 'Install into DIR/gitflash instead'
+    def install
+      run_command('skill install', Commands::SkillInstall,
+                  repo_required: options[:scope] == 'project')
+    end
+
+    desc 'show', 'Print the gitflash Agent Skill'
+    def show
+      puts File.read(Commands::SkillInstall::SOURCE)
+    end
+  end
+end

data/lib/gitflash/snapshot.rb

@@ -28,6 +28,9 @@ module Gitflash
       )
     end
 
+    # True for a snapshot `Snapshots#create` handed back instead of saving the same state again
+    def reused? = false
+
     # Untracked files this snapshot cannot bring back
     def unsaved_files
       skipped_files + excluded_files

data/lib/gitflash/snapshots.rb

@@ -22,11 +22,12 @@ module Gitflash
     end
 
     # Saves the current state. `branches` limits the recorded branches (nil records all).
-    # Returns the latest snapshot instead when nothing changed since it was taken.
+    # Returns the latest snapshot instead, marked `reused?`, when nothing changed since it was
+    # taken: its id is older than the change, but undo with it restores the state before it.
     def create(reason:, scope: SCOPES, branches: nil)
       state = @capture.call(scope, branches)
       latest = list.first
-      return latest if latest&.state == state
+      return ReusedSnapshot.new(latest) if latest&.state == state
 
       store(Snapshot.new(**identity, reason: reason, **state))
     end

data/lib/gitflash/ui.rb

@@ -41,7 +41,7 @@ module Gitflash
         $stdout.puts JSON.generate(envelope(status: status, **fields))
       else
         $stdout.puts TerminalText.safe(text)
-        $stdout.puts "Undo with: gitflash undo #{fields[:undo].id}" if fields[:undo]
+        $stdout.puts undo_hint(fields[:undo]) if fields[:undo]
       end
       OK_STATUSES.include?(status) ? 0 : 1
     end
@@ -111,11 +111,17 @@ module Gitflash
         dry_run: dry_run?,
         plan: plan,
         result: result,
-        undo: undo && { snapshot: undo.id, command: "gitflash undo #{undo.id}" },
+        undo: undo && { snapshot: undo.id, command: "gitflash undo #{undo.id}",
+                        reused: (true if undo.reused?) }.compact,
         error: error
       }.compact
     end
 
+    def undo_hint(undo)
+      note = undo.reused? ? ' (an earlier snapshot: nothing had changed since it was taken)' : ''
+      "Undo with: gitflash undo #{undo.id}#{note}"
+    end
+
     def prompt
       @prompt ||= Prompt.create
     end

data/lib/gitflash/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Gitflash
-  VERSION = '0.7.0'
+  VERSION = '0.8.0.beta1'
 end