gitflash 0.7.0.beta2 → 0.7.0.beta3

data/lib/gitflash/commands/undo.rb

@@ -2,15 +2,15 @@
 
 module Gitflash
   module Commands
-    # Restores a snapshot (the latest one by default). The current state is saved first,
-    # so an undo can itself be undone.
+    # Restores a snapshot (by default the latest one taken in this worktree). The current state
+    # is saved first, so an undo can itself be undone.
     class Undo < Base
       def call(id = nil)
         snapshot = find(id)
         return no_snapshots unless snapshot
 
         restore = build_restore(snapshot)
-        plan = restore.plan.merge(snapshot: snapshot.id)
+        plan = restore.plan.merge(snapshot: snapshot.id, reason: snapshot.reason)
         return nothing_to_undo(plan) if restore.empty?
 
         restore!(snapshot, restore, plan)
@@ -18,12 +18,19 @@ module Gitflash
 
       private
 
+      # Snapshots are shared by all worktrees of the repository, and another agent may have
+      # taken the newest one elsewhere; without an ID only this worktree's count
       def find(id)
-        return snapshots.list.first if id.nil?
+        return snapshots.list.find { |snapshot| own?(snapshot) } if id.nil?
 
         snapshots.find(id) || usage_error!('unknown_snapshot', "Unknown snapshot '#{id}'")
       end
 
+      # Taken in this worktree; snapshots from before worktree_path was recorded count too
+      def own?(snapshot)
+        snapshot.worktree_path.nil? || snapshot.worktree_path == repo.toplevel
+      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)
@@ -34,14 +41,14 @@ module Gitflash
 
       # 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)
+        !own?(snapshot) && (snapshot.scope?('head') || snapshot.scope?('worktree')) &&
+          !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')
-        return if snapshot.worktree_path == repo.toplevel
+        return if own?(snapshot)
 
         usage_error!('wrong_worktree', "Snapshot #{snapshot.id} was taken in " \
                                        "#{snapshot.worktree_path}; run gitflash undo there")
@@ -86,7 +93,10 @@ module Gitflash
       end
 
       def no_snapshots
-        ui.report(status: 'noop', result: { snapshot: nil }, text: 'No snapshots to undo')
+        ui.report(status: 'noop', result: { snapshot: nil },
+                  text: 'No snapshots of this worktree to undo. `gitflash snapshots` lists all: ' \
+                        'run `gitflash undo ID` in the worktree a snapshot was taken in (an ' \
+                        'ID from elsewhere works here only for a branches-only snapshot)')
       end
 
       def nothing_to_undo(plan)

data/lib/gitflash/commands/worktree_command.rb

@@ -11,10 +11,24 @@ module Gitflash
       end
 
       # The worktree named by a path or a branch; raises `unknown_worktree` when none matches
+      # A target that names one worktree by path and another by branch is refused, so a command
+      # never acts on the worktree the caller did not mean
       def find!(target, list = worktrees.list)
-        path = File.expand_path(target)
-        list.find { |worktree| worktree.path == path || worktree.branch == target } ||
-          usage_error!('unknown_worktree', "Unknown worktree: #{target}")
+        path = expand(target)
+        found = list.select { |worktree| worktree.path == path || worktree.branch == target }
+        usage_error!('unknown_worktree', "Unknown worktree: #{target}") if found.empty?
+        return found.first if found.one?
+
+        paths = found.map { |worktree| TerminalText.line(worktree.path) }.join(', ')
+        usage_error!('invalid_usage', "#{target} names more than one worktree (#{paths}); " \
+                                      'pass the full path')
+      end
+
+      # File.expand_path, but `~name` for an unknown user is a usage error, not a crash
+      def expand(path)
+        File.expand_path(path)
+      rescue ArgumentError => e
+        usage_error!('invalid_options', "Cannot read the path #{path}: #{e.message}")
       end
 
       def refuse_main!(worktree, action)

data/lib/gitflash/commands/worktree_remove.rb

@@ -6,7 +6,8 @@ module Gitflash
     # The main checkout, the worktree gitflash runs in, locked and dirty worktrees are refused
     # unless --force is given (the main checkout and the current one never can be removed).
     # Each removal saves a snapshot of the worktree first; `gitflash undo ID` brings the
-    # directory, its branch and its uncommitted files back.
+    # directory, its branch and its uncommitted files back. Ignored files cannot be saved, so a
+    # removal that deletes some needs --confirm TOKEN instead of --yes.
     class WorktreeRemove < WorktreeCommand
       include RemovalReport
 
@@ -56,7 +57,11 @@ module Gitflash
       def remove(chosen)
         plan = build_plan(chosen)
         return planned(plan, "Would remove:\n#{preview(chosen, plan)}") if dry_run?
-        return cancelled(plan) unless ui.confirm?(summary(chosen, plan), plan: plan)
+
+        # Ignored files are never saved, so losing them needs --confirm TOKEN, not --yes
+        confirmed = ui.confirm?(summary(chosen, plan), plan: plan,
+                                                       irreversible: loses_ignored?(plan))
+        return cancelled(plan) unless confirmed
 
         outcomes = chosen.map { |worktree| remove_one(worktree) }
         report_results(plan, outcomes)
@@ -64,6 +69,10 @@ module Gitflash
 
       def dry_run? = ui.dry_run?
 
+      def loses_ignored?(plan)
+        plan[:worktrees].any? { |row| row[:ignored_count].positive? }
+      end
+
       def preview(chosen, plan) = "#{bullets(chosen)}#{ignored_warning(plan)}"
 
       # The plan reported and returned in JSON; `wt clean` adds why each worktree was chosen
@@ -79,7 +88,7 @@ module Gitflash
 
       def remove_one(worktree)
         snapshot = snapshot_for(worktree)
-        unsaved = snapshot.skipped_files
+        unsaved = snapshot.unsaved_files
         return refuse_unsaved(worktree, unsaved) if unsaved.any?
 
         result = Worktrees.new(repo: repo).remove(worktree.path, force: force?)
@@ -90,8 +99,8 @@ module Gitflash
       def refuse_unsaved(worktree, files)
         shown = files.first(3).join(', ')
         shown += ", and #{files.size - 3} more" if files.size > 3
-        message = "#{files.size} untracked file(s) over 50 MB cannot be saved by a snapshot " \
-                  "(#{shown}); move or delete them first"
+        message = "#{files.size} untracked file(s) cannot be saved by a snapshot (over 50 MB or " \
+                  "matched by snapshot_exclude: #{shown}); move or delete them first"
         Removal.new(worktree: worktree, result: Result.new(success: false, output: message),
                     snapshot: nil)
       end

data/lib/gitflash/config.rb

@@ -4,31 +4,52 @@ require 'yaml'
 
 module Gitflash
   # Settings from `.gitflash.yml` in the main checkout and `~/.config/gitflash.yml`.
-  # Precedence: repository file, then user file, then built-in defaults.
+  # Precedence: repository file, then user file, then built-in defaults; for `worktree_dir` the
+  # user file wins, since it decides where on the user's disk checkouts are written.
   # Command-line flags are applied by the commands themselves and win over all of these.
   # An unknown key or a value of the wrong type raises a UsageError, so a typo never goes unnoticed.
-  Config = Data.define(:protected_patterns, :stale_days, :worktree_dir) do
+  Config = Data.define(:protected_patterns, :stale_days, :worktree_dir, :worktree_dir_from_repo,
+                       :snapshot_exclude) do
     # `root` is the main checkout; `home` is where the user file lives. The repository file wins
     # key by key, except `protected`: both files add patterns, so a repository can protect more
-    # branches but never remove what the user protects.
+    # branches but never remove what the user protects; and `worktree_dir`, where the user file
+    # wins. A cloned repository's file may only place worktrees next to the main checkout.
     def self.load(root:, home: Dir.home)
-      layers = [File.join(home, ConfigKeys::USER_FILE), File.join(root, ConfigKeys::REPO_FILE)]
-               .map { |path| read(path) }
-      values = layers.reduce(ConfigKeys::DEFAULTS) { |merged, layer| merged.merge(layer) }
-      new(protected_patterns: layers.flat_map { |layer| layer.fetch('protected', []) }.uniq,
-          stale_days: values['stale_days'], worktree_dir: values['worktree_dir'])
+      user = read(File.join(home, ConfigKeys::USER_FILE))
+      repo = read(File.join(root, ConfigKeys::REPO_FILE), repository: true)
+      values = ConfigKeys::DEFAULTS.merge(user).merge(repo)
+      new(protected_patterns: both([user, repo], 'protected'), stale_days: values['stale_days'],
+          snapshot_exclude: both([user, repo], 'snapshot_exclude'), **worktree_dir_of(user, repo))
     end
 
+    # Lists that both files add to
+    def self.both(layers, key)
+      layers.flat_map { |layer| layer.fetch(key, []) }.uniq
+    end
+    private_class_method :both
+
+    # The user file wins for worktree_dir; a value from the repository is checked again where
+    # it leads (see ConfigKeys.check_contained!)
+    def self.worktree_dir_of(user, repo)
+      from_repo = !user.key?('worktree_dir') && repo.key?('worktree_dir')
+      dir = from_repo ? repo['worktree_dir'] : user.fetch('worktree_dir', ConfigKeys::DEFAULT_WORKTREE_DIR)
+      { worktree_dir: dir,
+        worktree_dir_from_repo: from_repo }
+    end
+    private_class_method :worktree_dir_of
+
     def self.defaults
-      new(protected_patterns: [], stale_days: 30, worktree_dir: ConfigKeys::DEFAULT_WORKTREE_DIR)
+      new(protected_patterns: [], stale_days: 30, worktree_dir: ConfigKeys::DEFAULT_WORKTREE_DIR,
+          worktree_dir_from_repo: false, snapshot_exclude: [])
     end
 
-    def self.read(path)
+    def self.read(path, repository: false)
       return {} unless File.file?(path)
 
       reject_duplicate_keys!(path)
       data = YAML.safe_load_file(path) || {}
       validate!(data, path)
+      check_repository_dir!(data['worktree_dir'], path) if repository
       data
     rescue Psych::Exception, SystemCallError, IOError => e
       raise invalid(path, "cannot be read (#{e.message.lines.first.strip})")
@@ -77,14 +98,41 @@ module Gitflash
     end
     private_class_method :check_types!
 
+    # A repository's file comes with the clone, so its worktree_dir must stay next to the main
+    # checkout: relative, no `~`, and not climbing above the main checkout's parent
+    def self.check_repository_dir!(template, path)
+      return if template.nil? || ConfigKeys.contained?(template)
+
+      raise invalid(path, "'worktree_dir' must be a relative path that stays next to the " \
+                          'repository (set other places in ~/.config/gitflash.yml)')
+    end
+    private_class_method :check_repository_dir!
+
     def self.invalid(path, problem)
       UsageError.new("#{path} #{problem}", code: 'invalid_config')
     end
     private_class_method :invalid
 
-    # True when the branch name matches a configured pattern (shell-style `*` and `?`)
+    # True when the branch name matches a configured pattern (shell-style `*`, `?`, `[abc]` and
+    # `{a,b}`)
     def protected?(name)
-      protected_patterns.any? { |pattern| File.fnmatch?(pattern, name) }
+      protected_patterns.any? { |pattern| File.fnmatch?(pattern, name, File::FNM_EXTGLOB) }
+    end
+
+    # True when an untracked file must stay out of snapshots: the pattern matches its path or
+    # its name (`*.pem`, `.env*`, `secrets/*`)
+    def snapshot_excluded?(path)
+      flags = File::FNM_PATHNAME | File::FNM_DOTMATCH
+      names = excluded_candidates(path)
+      snapshot_exclude.any? { |pattern| names.any? { |name| File.fnmatch?(pattern, name, flags) } }
+    end
+
+    # The path, its name, and every directory above it: a pattern that matches a directory
+    # (`secrets`, `secrets/*`) covers everything below it, as in .gitignore
+    def excluded_candidates(path)
+      parts = path.split('/')
+      dirs = (1...parts.size).map { |count| parts.first(count).join('/') }
+      [path, File.basename(path), *dirs]
     end
 
     # Directory for a new worktree. `%<repo>s` and `%<branch>s` are replaced as plain text; a
@@ -92,7 +140,9 @@ module Gitflash
     # folders.
     def worktree_path(root:, branch:)
       path = worktree_dir.gsub('%<repo>s') { File.basename(root) }.gsub('%<branch>s') { branch }
-      File.expand_path(path, root)
+      path = File.expand_path(path, root)
+      ConfigKeys.check_contained!(path, root) if worktree_dir_from_repo
+      path
     end
   end
 end

data/lib/gitflash/config_keys.rb

@@ -7,18 +7,51 @@ module Gitflash
     USER_FILE = File.join('.config', 'gitflash.yml')
     DEFAULT_WORKTREE_DIR = '../%<repo>s.worktrees/%<branch>s'
     DEFAULTS = {
-      'protected' => [], 'stale_days' => 30, 'worktree_dir' => DEFAULT_WORKTREE_DIR
+      'protected' => [], 'stale_days' => 30, 'worktree_dir' => DEFAULT_WORKTREE_DIR,
+      'snapshot_exclude' => []
     }.freeze
     PLACEHOLDERS = ['%<repo>s', '%<branch>s'].freeze
     MAX_TEMPLATE_LENGTH = 512
     CHECKS = {
-      'protected' => [->(v) { v.is_a?(Array) && v.all?(String) },
-                      'a list of branch name patterns'],
+      'protected' => [->(v) { v.is_a?(Array) && v.all? { |pattern| branch_pattern?(pattern) } },
+                      'a list of branch name patterns (no spaces, control characters, ~, ^ or :)'],
       'stale_days' => [->(v) { v.is_a?(Integer) && v.positive? }, 'a positive whole number'],
       'worktree_dir' => [->(v) { template?(v) },
-                         'a path of up to 512 characters that uses only %<repo>s and %<branch>s']
+                         'a path of up to 512 characters that uses only %<repo>s and %<branch>s'],
+      'snapshot_exclude' => [->(v) { v.is_a?(Array) && v.all?(String) },
+                             'a list of file name patterns']
     }.freeze
 
+    # Whether a template resolves inside the parent of the main checkout, for any repository and
+    # branch name (branch names cannot hold `..`)
+    def self.contained?(template)
+      return false if template.start_with?('/', '~')
+
+      root = '/parent/repo'
+      path = template.gsub('%<repo>s', 'repo').gsub('%<branch>s', 'branch')
+      File.expand_path(path, root).start_with?("#{File.dirname(root)}/")
+    end
+
+    # A pattern that can match a branch name: characters git refuses in branch names, such as a
+    # space at either end, would make it match nothing without any warning
+    def self.branch_pattern?(value)
+      return false unless value.is_a?(String) && !value.empty?
+      return false if value.match?(/[\x00-\x20\x7F~^:\\]/)
+
+      # `..` is never in a branch name; inside `{..,a}` it is only one of the alternatives
+      alternatives(value).any? { |pattern| !pattern.include?('..') }
+    end
+
+    # The patterns `{a,b}` stands for, innermost braces first, as File::FNM_EXTGLOB reads them
+    def self.alternatives(pattern)
+      match = pattern.match(/\{([^{}]*)\}/)
+      return [pattern] unless match
+
+      match[1].split(',', -1).flat_map do |choice|
+        alternatives(match.pre_match + choice + match.post_match)
+      end
+    end
+
     # A path template: the two placeholders are the only `%` directives, so a width such as
     # `%<repo>999999999s` can never make Ruby build a huge string
     def self.template?(value)
@@ -27,5 +60,20 @@ module Gitflash
 
       !PLACEHOLDERS.reduce(value) { |rest, placeholder| rest.gsub(placeholder, '') }.include?('%')
     end
+
+    # A repository's worktree_dir passed a check on the text alone; a symbolic link in the
+    # repository (`wt-link -> /elsewhere`) could still lead out, so the real location of the
+    # deepest existing directory on the way must stay next to the main checkout too
+    def self.check_contained!(path, root)
+      parent = File.realpath(File.dirname(root))
+      existing = path
+      existing = File.dirname(existing) until File.exist?(existing)
+      real = File.join(File.realpath(existing), path.delete_prefix(existing))
+      return if real.start_with?("#{parent}/")
+
+      raise UsageError.new("worktree_dir in #{REPO_FILE} leads to #{real}, outside " \
+                           "#{parent}; set worktree_dir in ~/.config/gitflash.yml to use it",
+                           code: 'invalid_config')
+    end
   end
 end

data/lib/gitflash/confirmation_required.rb

@@ -2,10 +2,14 @@
 
 module Gitflash
   # Raised when a destructive command runs without a terminal and without --yes.
-  # Carries the plan so the caller can review it and re-run with --yes.
+  # Carries the plan so the caller can review it and re-run with --yes, or, for a change
+  # gitflash undo cannot revert, the token to pass to --confirm.
   class ConfirmationRequired < Error
-    def initialize(message = nil, plan: nil)
+    attr_reader :confirm_token
+
+    def initialize(message = nil, plan: nil, confirm_token: nil)
       super(message, code: 'confirmation_required', plan: plan)
+      @confirm_token = confirm_token
     end
 
     def exit_code

data/lib/gitflash/hook/claude.rb

@@ -41,9 +41,11 @@ module Gitflash
         return nil if targets.empty?
         return deny(targets) if @mode == 'deny'
 
-        saved = merge_by_dir(targets).filter_map { |target| save(target) }
-        # Asking is the user's protection: it must not depend on a snapshot having been saved
-        saved.empty? && @mode != 'ask' ? nil : output(saved, targets)
+        merged = merge_by_dir(targets)
+        saved = merged.filter_map { |target| save(target) }
+        # Asking is the user's protection: it must not depend on a snapshot having been saved.
+        # A command that runs where nothing could be saved is always reported to the agent.
+        output(saved, merged - saved.map(&:first))
       end
 
       # Recording is a side feature: when it fails, snapshots and the ask or deny decision still run
@@ -84,15 +86,11 @@ module Gitflash
 
       # One snapshot per directory, covering every command run there
       def merge_by_dir(targets)
-        targets.group_by(&:dir).map do |dir, group|
-          CommandParser::Target.new(
-            dir: dir, command: group.map(&:command).join(' && '),
-            scope: group.flat_map(&:scope).uniq, branches: group.flat_map(&:branches).uniq
-          )
-        end
+        targets.group_by(&:dir).map { |dir, group| CommandParser::Target.merge(dir, group) }
       end
 
-      # [target, snapshot], or nil when the directory is not a git work tree
+      # [target, snapshot], or nil when the directory is not a git work tree or saving failed.
+      # A failure must not stop the ask decision, so it is warned about here and not raised.
       def save(target)
         return nil unless Dir.exist?(target.dir)
 
@@ -103,6 +101,9 @@ module Gitflash
                                             scope: target.scope, branches: branches(target))
           [target, snapshot]
         end
+      rescue StandardError => e
+        warn "gitflash hook: could not save a snapshot in #{target.dir} (#{e.message})"
+        nil
       end
 
       # Full ref shortened by removing refs/heads/ only; `--short` changes when a tag has the name
@@ -110,14 +111,18 @@ module Gitflash
         git('symbolic-ref', '--quiet', 'HEAD')&.delete_prefix(Repo::HEADS)
       end
 
+      # The branches to save; nil (all of them) when the command does not name its branches, as
+      # in `xargs git branch -D < list`
       def branches(target)
+        return nil if target.branches.empty?
+
         target.branches.filter_map do |name|
           name == :current ? current_branch : name
         end
       end
 
-      def output(saved, targets)
-        context = saved.empty? ? Messages.unsaved(targets) : Messages.saved(saved)
+      def output(saved, unsaved)
+        context = Messages.context(saved, unsaved)
         specific = { hookEventName: EVENT, additionalContext: context }
         if @mode == 'ask'
           specific[:permissionDecision] = 'ask'

data/lib/gitflash/hook/command_parser.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'shellwords'
-
 module Gitflash
   module Hook
     # Finds git commands in a shell command line that can lose work git itself cannot restore:
@@ -13,16 +11,42 @@ module Gitflash
     # `cd DIR` and `git -C DIR`, and may report a command more often than needed. An extra
     # snapshot is harmless; a missed one is not.
     class CommandParser
-      # dir: where to take the snapshot; branches: names, or :current for the checked-out one
-      Target = Data.define(:dir, :command, :scope, :branches)
+      # dir: where to take the snapshot; branches: names, or :current for the checked-out one;
+      # guessed: the shell decides the directory (`cd "$REPO"`), so dir is only a fallback;
+      # ignored: whether the command also deletes ignored files, which no snapshot saves
+      Target = Data.define(:dir, :command, :scope, :branches, :guessed, :ignored) do
+        # One target for all the commands of a group that run in dir
+        def self.merge(dir, group)
+          new(dir: dir, command: group.map(&:command).join(' && '),
+              scope: group.flat_map(&:scope).uniq, branches: merged_branches(group),
+              guessed: group.any?(&:guessed), ignored: group.any?(&:ignored))
+        end
+
+        # A target that saves branches without naming them saves every branch, so the merge
+        # does too: naming the others' branches would drop the ones it could not name
+        def self.merged_branches(group)
+          all = group.any? { |target| target.scope.include?('branches') && target.branches.empty? }
+          all ? [] : group.flat_map(&:branches).uniq
+        end
+      end
 
-      PREFIXES = %w[sudo command exec time nohup env].freeze
       SHELLS = %w[bash sh zsh dash ksh].freeze
       MAX_NESTING = 3
-      OPTIONS_WITH_VALUE = %w[-c --git-dir --work-tree --namespace --exec-path --config-env].freeze
+      # 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
+                                         config ls-files remote describe blame grep tag init
+                                         clone mv]).freeze
+
+      DIR_COMMANDS = %w[cd pushd popd].freeze
 
-      def initialize(cwd)
+      # `aliases` returns the git aliases configured for a directory, as { name => value }
+      def initialize(cwd, aliases: GitInvocation.method(:configured_aliases))
         @cwd = cwd
+        @aliases = aliases
+        @alias_cache = {}
+        @invocation = GitInvocation.new(dir_after: method(:change_dir),
+                                        aliases: method(:aliases_in))
       end
 
       # Git commands that can lose work, with what to save before them
@@ -31,8 +55,10 @@ module Gitflash
           rule = Rules.for(git.subcommand, git.args, git.dir)
           next unless rule
 
-          Target.new(dir: rule.fetch(:dir, git.dir), command: git.command, scope: rule[:scope],
-                     branches: rule[:branches] || [])
+          dir = rule.fetch(:dir, git.dir)
+          Target.new(dir: dir.to_s, command: git.command, scope: rule[:scope],
+                     branches: rule[:branches] || [], guessed: Paths.guessed?(dir),
+                     ignored: rule.fetch(:ignored, false))
         end
       end
 
@@ -51,88 +77,85 @@ module Gitflash
       GitCommand = Data.define(:dir, :command, :subcommand, :args)
 
       def git_commands(command_line, dir = @cwd, depth = 0)
-        segments(command_line).flat_map do |segment|
-          words = words(segment)
-          next [] if words.empty?
-
-          if words.first == 'cd'
-            dir = File.expand_path(words[1] || Dir.home, dir)
-            next []
+        stack = []
+        ShellText.segments(command_line).flat_map do |segment|
+          words = CommandWords.new(segment)
+          if DIR_COMMANDS.include?(words.words.first)
+            dir = dir_after(words.words, dir, stack)
+            next substituted(segment, dir, depth)
           end
-          commands_in(words, dir, segment.strip, depth)
+          substituted(segment, dir, depth) + in_segment(words, dir, segment.strip, depth)
         end
       end
 
-      # The git command of one segment, or the ones inside `bash -c "..."` and `eval "..."`
-      def commands_in(words, dir, segment, depth)
-        return [git_command(words, dir, segment)] if File.basename(words.first) == 'git'
+      # `cd DIR` and `pushd DIR` move, `pushd` remembering where it was; `popd` goes back there,
+      # or to the directory Claude runs in when the line pushed nothing
+      def dir_after(words, dir, stack)
+        return stack.pop || @cwd if words.first == 'popd'
 
-        script = nested_script(words)
-        script && depth < MAX_NESTING ? git_commands(script, dir, depth + 1) : []
+        stack.push(dir) if words.first == 'pushd'
+        change_dir(words[1] || Dir.home, dir)
       end
 
-      # The script text passed to a shell (`bash -c`, `sh -lc`) or to `eval`
-      def nested_script(words)
-        return words.drop(1).join(' ') if words.first == 'eval'
-        return nil unless SHELLS.include?(File.basename(words.first))
+      def in_segment(words, dir, segment, depth)
+        return [] if words.words.empty?
 
-        index = words.index { |word| word.match?(/\A-[a-z]*c[a-z]*\z/) }
-        index && words[index + 1]
+        dir = change_dir(words.chdir, dir) if words.chdir
+        commands_in(words.words, dir, segment, depth, words.env)
       end
 
-      # Splits on unquoted ; & | and newlines
-      def segments(line)
-        parts = [+'']
-        quote = nil
-        line.each_char do |char|
-          if quote
-            quote = nil if char == quote
-          elsif ["'", '"'].include?(char)
-            quote = char
-          elsif ";&|\n".include?(char)
-            parts << +''
-            next
-          end
-          parts.last << char
+      # Git commands inside `$(...)`, `<(...)` and backticks, which the shell runs first
+      def substituted(command_line, dir, depth)
+        ShellText.substitutions(command_line).flat_map do |script|
+          nested(script, dir, depth)
         end
-        parts.reject { |part| part.strip.empty? }
       end
 
-      # Shell words without subshell brackets, environment assignments and wrappers like sudo
-      def words(segment)
-        words = split(segment).map { |word| unwrap(word) }.reject(&:empty?)
-        words.shift while words.first && prefix?(words.first)
-        words
+      # The git commands of a script inside this one. Past the nesting limit a script that
+      # mentions git counts as risky without being read, so deep nesting cannot hide a command.
+      def nested(script, dir, depth)
+        return git_commands(script, dir, depth + 1) if depth < MAX_NESTING
+        return [] unless script.match?(/\bgit\b/)
+
+        [GitCommand.new(dir: dir, command: script.strip, subcommand: Rules::UNREAD, args: [])]
       end
 
-      def prefix?(word)
-        PREFIXES.include?(word) || word.match?(/\A\w+=/)
+      # The git command of one segment, or the ones inside `bash -c "..."`, `eval "..."`,
+      # `find -exec` and `!` aliases
+      def commands_in(words, dir, segment, depth, env = {})
+        words = Wrappers.find_exec(words) || words
+        git = File.basename(words.first.to_s) == 'git'
+        return git_command(words, dir, segment, depth, env) if git
+
+        script = nested_script(words)
+        script ? nested(script, dir, depth) : []
       end
 
-      def split(segment)
-        Shellwords.split(segment)
-      rescue ArgumentError
-        segment.split
+      # The script text passed to a shell (`bash -c`, `sh -lc`) or to `eval`
+      def nested_script(words)
+        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 + 1]
       end
 
-      def unwrap(word)
-        word.delete_prefix('(').delete_prefix('{').delete_suffix(')').delete_suffix('}')
+      # The directory after `cd PATH` or `git -C PATH`. A path the shell decides when it runs
+      # (`cd "$(git rev-parse --show-toplevel)"`, `cd "$REPO"`, `cd -`) falls back to the
+      # directory Claude runs in: a snapshot there is better than none.
+      def change_dir(path, dir)
+        Paths.change_dir(path, dir, @cwd)
       end
 
-      def git_command(words, dir, command)
-        index, dir = skip_git_options(words, dir)
-        GitCommand.new(dir: dir, command: command, subcommand: words[index],
-                       args: words[(index + 1)..] || [])
+      def git_command(words, dir, command, depth, env)
+        git = @invocation.parse(words, dir, env)
+        return nested(git.script, git.dir, depth) if git.script
+
+        [GitCommand.new(dir: git.dir, command: command, subcommand: git.subcommand, args: git.args)]
       end
 
-      # Index of the subcommand, and the directory after any -C options
-      def skip_git_options(words, dir)
-        index = 1
-        while (option = words[index])&.start_with?('-')
-          dir = File.expand_path(words[index + 1].to_s, dir) if option == '-C'
-          index += option == '-C' || OPTIONS_WITH_VALUE.include?(option) ? 2 : 1
-        end
-        [index, dir]
+      def aliases_in(dir)
+        @alias_cache[dir] ||= @aliases.call(dir)
       end
     end
   end