gitflash 0.6.0 → 0.7.0.beta1

data/lib/gitflash/commands/hook_install.rb

@@ -4,35 +4,43 @@ require 'fileutils'
 
 module Gitflash
   module Commands
-    # Registers `gitflash hook claude` as a Claude Code PreToolUse hook for Bash commands.
-    # Merges into the settings file and keeps everything else in it.
+    # 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)
-        return already_installed(plan) if entry && entry['command'] == plan[:command]
+        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, plan)
+        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,
-          applies_to: settings.applies_to(scope) }
+          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, plan)
-        entry ? entry['command'] = plan[:command] : add_entry(data, plan[:command])
+      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,
@@ -57,9 +65,9 @@ module Gitflash
                   text: "Already installed in #{plan[:file]}.\nIt applies to #{plan[:applies_to]}.")
       end
 
-      def add_entry(data, command)
+      def add_entry(data, event, command)
         hooks = (data['hooks'] ||= {})
-        (hooks['PreToolUse'] ||= []) << {
+        (hooks[event] ||= []) << {
           'matcher' => 'Bash',
           'hooks' => [{ 'type' => 'command', 'command' => command, 'timeout' => 30 }]
         }

data/lib/gitflash/commands/hook_status.rb

@@ -9,9 +9,7 @@ module Gitflash
       def call
         settings = Hook::Settings.new(inside_repo? ? repo : nil)
         files = settings.scopes.map { |scope| file_status(settings, scope) }
-        executable = find_executable
-        active = executable && files.any? { |file| file[:installed] }
-        result = { active: active ? true : false, executable: executable, files: files }
+        result = summary(files, find_executable)
         ui.report(status: 'done', result: result, text: text(result))
       end
 
@@ -24,10 +22,19 @@ module Gitflash
         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)
-        entry = settings.entry(settings.read(path))
+        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
 
@@ -39,7 +46,7 @@ module Gitflash
       def text(result)
         lines = [headline(result)]
         result[:files].each do |file|
-          state = file[:installed] ? "installed (#{file[:command]})" : 'not installed'
+          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
@@ -47,8 +54,13 @@ module Gitflash
         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 'gitflash hook: active' if result[:active]
+        return active_headline(result) if result[:active]
 
         reason = if result[:executable]
                    'run `gitflash hook install`'
@@ -57,6 +69,12 @@ module Gitflash
                  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

data/lib/gitflash/commands/pick_outcome.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Gitflash
+  module Commands
+    # How `pick` and its --continue / --skip / --abort report a git cherry-pick run: done, or
+    # stopped on conflicts (status `failed`, error code `conflict`) with what is left to do.
+    module PickOutcome
+      private
+
+      def cherry_pick
+        @cherry_pick ||= CherryPick.new
+      end
+
+      # `requested` are the commits the user asked for, in order; `snapshot` reverts the start
+      def outcome(plan, result, requested, snapshot)
+        return finished(plan, requested, snapshot) if result.success? && !cherry_pick.in_progress?
+        return conflict(plan, result, requested, snapshot) if cherry_pick.in_progress?
+
+        git_error!('cherry-pick', result)
+      end
+
+      def finished(plan, requested, snapshot)
+        head = repo.resolve_commit('HEAD')
+        text = "Applied #{requested.size} commit(s), now at #{head[0, 7]}"
+        ui.report(status: 'done', plan: plan, result: { applied: requested, head: head },
+                  undo: snapshot, text: text)
+      end
+
+      def conflict(plan, result, requested, snapshot)
+        progress = cherry_pick.progress
+        text = conflict_text(progress, result)
+        details = { applied: requested - progress.remaining - [progress.current],
+                    current: progress.current, conflicted: progress.conflicted,
+                    remaining: progress.remaining }
+        ui.report(status: 'failed', plan: plan, result: details, undo: snapshot, text: text,
+                  error: { code: 'conflict', exit_code: 1, message: text })
+      end
+
+      def conflict_text(progress, result)
+        files = progress.conflicted.map { |file| "* #{file}" }.join("\n")
+        "Stopped on conflicts in:\n#{files}\n#{result.output}\n" \
+          'Resolve them and stage the files, then run `gitflash pick --continue`; ' \
+          'or `gitflash pick --skip` / `gitflash pick --abort`.'
+      end
+
+      def current_branch_names
+        branch = repo.current_branch
+        branch ? [branch] : []
+      end
+    end
+  end
+end

data/lib/gitflash/commands/removal_report.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Gitflash
+  module Commands
+    # Reports the outcome of removing worktrees: one row per worktree with its own snapshot and
+    # undo command, failures with their reason. Used by `wt remove` and `wt clean`.
+    module RemovalReport
+      # What happened to one worktree; `snapshot` is nil when it was not removed
+      Removal = Data.define(:worktree, :result, :snapshot)
+
+      private
+
+      # Ignored files are never saved by snapshots, so `undo` cannot bring them back
+      def ignored_warning(plan)
+        rows = plan[:worktrees].select { |row| row[:ignored_count].positive? }
+        return '' if rows.empty?
+
+        lines = rows.map { |row| ignored_line(row) }
+        "\n\nIgnored files are not saved by snapshots and will be lost for good:\n" \
+          "#{lines.join("\n")}"
+      end
+
+      def ignored_line(row)
+        "* #{row[:path]}: #{row[:ignored_count]} (#{row[:ignored].join(', ')})"
+      end
+
+      def report_results(plan, outcomes)
+        removed, failed = outcomes.partition { |outcome| outcome.result.success? }
+        result = { removed: removed.map { |outcome| removed_row(outcome) },
+                   failed: failed.map { |outcome| failed_row(outcome) } }
+        ui.report(status: failed.empty? ? 'done' : 'failed', plan: plan, result: result,
+                  error: failure(failed, outcomes), text: results_text(result),
+                  undo: single_undo(removed))
+      end
+
+      # `undo` in the envelope only when one worktree was removed; each row has its own
+      def single_undo(removed)
+        removed.first.snapshot if removed.size == 1
+      end
+
+      def failed_row(outcome)
+        { path: outcome.worktree.path, error: outcome.result.output }
+      end
+
+      def removed_row(outcome)
+        worktree = outcome.worktree
+        { path: worktree.path, branch: worktree.branch, head: worktree.head,
+          snapshot: outcome.snapshot.id, undo: "gitflash undo #{outcome.snapshot.id}" }
+      end
+
+      def failure(failed, outcomes)
+        return nil if failed.empty?
+
+        { code: 'git_failed', exit_code: 1,
+          message: "#{failed.size} of #{outcomes.size} worktrees were not removed" }
+      end
+
+      def results_text(result)
+        lines = result[:removed].map { |row| "Removed #{row[:path]} (undo: #{row[:undo]})" }
+        lines += result[:failed].map { |row| "Not removed #{row[:path]}: #{row[:error]}" }
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/gitflash/commands/undo.rb

@@ -9,8 +9,7 @@ module Gitflash
         snapshot = find(id)
         return no_snapshots unless snapshot
 
-        check_worktree!(snapshot)
-        restore = Restore.new(snapshot)
+        restore = build_restore(snapshot)
         plan = restore.plan.merge(snapshot: snapshot.id)
         return nothing_to_undo(plan) if restore.empty?
 
@@ -25,6 +24,20 @@ module Gitflash
         snapshots.find(id) || usage_error!('unknown_snapshot', "Unknown snapshot '#{id}'")
       end
 
+      # A snapshot of a worktree that is gone is restored by adding the worktree again
+      def build_restore(snapshot)
+        return WorktreeRevival.new(snapshot, repo: repo) if removed_worktree?(snapshot)
+
+        check_worktree!(snapshot)
+        Restore.new(snapshot)
+      end
+
+      # The snapshot was taken in a worktree whose directory no longer exists
+      def removed_worktree?(snapshot)
+        (snapshot.scope?('head') || snapshot.scope?('worktree')) &&
+          snapshot.worktree_path != repo.toplevel && !File.exist?(snapshot.worktree_path)
+      end
+
       # Branches are shared between worktrees; HEAD and files belong to one worktree
       def check_worktree!(snapshot)
         return unless snapshot.scope?('head') || snapshot.scope?('worktree')
@@ -43,21 +56,34 @@ module Gitflash
       end
 
       def apply(snapshot, restore, plan)
-        before = snapshots.create(reason: "before undo #{snapshot.id}", scope: snapshot.scope,
+        before = snapshots.create(reason: "before undo #{snapshot.id}", scope: restore.scope,
                                   branches: snapshot.branches.keys)
         failure = restore.apply
         raise_failure(failure, before, plan) if failure
 
+        report_done(snapshot, plan, before)
+      end
+
+      def report_done(snapshot, plan, before)
         ui.report(status: 'done', plan: plan, result: { snapshot: snapshot.id }, undo: before,
                   text: "Restored snapshot #{snapshot.id}:\n#{describe(plan)}")
       end
 
       def raise_failure(failure, before, plan)
         message = "gitflash undo failed:\n#{failure.output}\n" \
-                  "The state before this undo is saved as snapshot #{before.id}."
+                  "The state before this undo is saved as snapshot #{before.id}." \
+                  "#{revival_hint(plan)}"
         raise Error.new(message, code: 'git_failed', plan: plan)
       end
 
+      # That snapshot cannot take the added worktree away again
+      def revival_hint(plan)
+        return '' unless plan[:recreate_worktree]
+
+        "\nThe worktree #{plan[:recreate_worktree]} was added again and may be partly restored; " \
+          "remove it with: gitflash wt remove #{plan[:recreate_worktree]} --force"
+      end
+
       def no_snapshots
         ui.report(status: 'noop', result: { snapshot: nil }, text: 'No snapshots to undo')
       end
@@ -74,10 +100,16 @@ module Gitflash
 
       def describe(plan)
         lines = plan[:branches].map { |change| branch_line(change) }
-        lines << head_line(plan[:head]) if plan[:head]
+        lines << "* add worktree #{plan[:recreate_worktree]} again" if plan[:recreate_worktree]
+        lines << head_line(plan[:head]) if plan[:head] && !plan[:recreate_worktree]
+        (lines + file_lines(plan)).join("\n")
+      end
+
+      def file_lines(plan)
+        lines = []
         lines << '* restore tracked, staged and untracked files' if plan[:worktree]
         lines << "* restore #{plan[:stashes].size} stash entries" if plan[:stashes].any?
-        lines.join("\n")
+        lines
       end
 
       def branch_line(change)