squared 0.3.11 → 0.4.0

data/lib/squared/workspace/project/git.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require 'date'
+require 'time'
+require 'digest'
+
 module Squared
   module Workspace
     module Git
@@ -7,29 +11,27 @@ module Squared
       GIT_PROTO = %r{^(?:https?|ssh|git|file)://}i.freeze
       private_constant :GIT_REPO, :GIT_PROTO
 
-      def git(name, uri = nil, base: nil, repo: [], options: {})
+      attr_reader :revfile
+
+      def git(name, uri = nil, base: nil, repo: [], options: {}, cache: nil)
         data = {}
         check = ->(proj) { proj.is_a?(Project::Git) && !proj.exclude?(Project::Git.ref) && git_clone?(proj.path) }
         if uri.is_a?(Array)
           base = name
-          uri.each do |val|
-            if (proj = @project[val.to_s]) && check.(proj)
-              repo << proj
-            end
-          end
+          uri.each { |val| repo << proj if (proj = @project[val.to_s]) && check.(proj) }
         elsif uri
           data[name.to_s] = uri
         elsif name.is_a?(Enumerable)
           data = name.to_h
-        elsif name.is_a?(String) && name =~ GIT_PROTO
+        elsif name.is_a?(String) && name.match?(GIT_PROTO)
           base = name
           @project.each_value { |proj| repo << proj if !proj.parent && check.(proj) }
         else
-          warn log_message(Logger::WARN, name, subject: 'git', hint: 'invalid') if warning
+          warn log_message(Logger::WARN, name, subject: 'git', hint: 'invalid', pass: true) if warning
           return self
         end
         if base
-          base = base =~ GIT_PROTO ? "#{base.chomp('/')}/" : @root.join(base)
+          base = base.match?(GIT_PROTO) ? "#{base.chomp('/')}/" : @root.join(base)
           repo.each do |target|
             if target.is_a?(Project::Git)
               data[target.localname] = target.project
@@ -59,6 +61,23 @@ module Squared
           (GIT_REPO[main] ||= {})[key] = [uri.to_s, opts]
           (@kind[key] ||= []) << Project::Git
         end
+        if cache == true
+          revbuild
+        elsif cache
+          revbuild(file: cache)
+        end
+        self
+      end
+
+      def revbuild(file: nil)
+        @revfile = @home.join(file || "#{@main}.revb")
+        @revdoc = JSON.parse(@revfile.read) if @revfile.exist?
+      rescue StandardError => e
+        @revfile = nil
+        warn log_message(Logger::WARN, e, pass: true) if @warning
+        self
+      else
+        @revdoc = {} unless @revdoc.is_a?(Hash)
         self
       end
 
@@ -66,36 +85,86 @@ module Squared
         (ret = GIT_REPO[main]) && ret[name]
       end
 
+      def rev_entry(*keys, val: nil, create: true)
+        return unless @revdoc
+        return @revdoc.dig(*keys) unless val
+
+        data = @revdoc
+        last = keys.pop
+        for key in keys
+          if data[key].is_a?(Hash)
+            data = data[key]
+          elsif create
+            data = data[key] = {}
+          else
+            return
+          end
+        end
+        data[last] = val
+      end
+
+      def rev_timeutc(*keys)
+        rev_entry(*keys, val: rev_timenow)
+      end
+
+      def rev_timesince(*keys, clock: false)
+        epoch = rev_timenow - rev_entry(*keys).to_i
+      rescue StandardError
+        nil
+      else
+        time_format(epoch, clock: clock)
+      end
+
+      def rev_clear(name)
+        rev_write if rev_entry(name, 'revision', val: '', create: false)
+      end
+
+      def rev_write(name = nil, data = nil, utc: nil)
+        return unless @revfile
+
+        if name
+          data&.each { |key, val| rev_entry(name, key, val: val) }
+          rev_timeutc(name, utc) if utc
+        end
+        File.write(@revfile, JSON.pretty_generate(@revdoc))
+      end
+
       def git_clone?(path, name = nil)
         return false if name && !git_repo(name)
 
         !path.exist? || path.empty?
       end
+
+      private
+
+      def rev_timenow
+        DateTime.now.strftime('%Q').to_i + time_offset
+      end
     end
     Application.include Git
 
     module Project
       class Git < Base
-        include Prompt
-
         OPT_GIT = {
-          branch: %w[a|all create-reflog i|ignore-case q|quiet r|remotes v|verbose vv abbrev=i color=b column=b
-                     contains=e format=q merged=e no-contains=e no-merged=e points-at=e u|set-upstream-to=e sort=q
+          common: %w[bare p|paginate P|no-pager glob-pathspecs icase-pathspecs literal-pathspecs no-optional-locks
+                     no-replace-objects noglob-pathspecs c=q config-env=q exec-path=p namespace=p].freeze,
+          branch: %w[a|all create-reflog i|ignore-case q|quiet r|remotes v|verbose abbrev=i color=b column=b
+                     contains=b format=q merged=b no-contains=b no-merged=b points-at=e u|set-upstream-to=e sort=q
                      t|track=b].freeze,
           checkout: %w[l d|detach f|force ignore-other-worktrees ignore-skip-worktree-bits m|merge p|patch
-                       pathspec-file-nul q|quiet orphan=e ours theirs conflict=b pathspec-from-file=p
+                       pathspec-file-nul q quiet orphan=e ours theirs conflict=b pathspec-from-file=p
                        t|track=b].freeze,
+          clean: %w[d x X f|force i|interactive n|dry-run q|quiet e|exlcude=q].freeze,
           diff: {
             base: %w[0 1|base 2|ours 3|theirs].freeze,
             show: %w[s exit-code histogram].freeze
           }.freeze,
           fetch: {
-            base: %w[multiple progress P|prune-tags refetch stdin u|update-head-ok
+            base: %w[multiple progress P|prune-tags refetch stdin u|update-head-ok recurse-submodules=b
                      recurse-submodules-default=b].freeze,
-            pull: %w[4 6 n t a|append atomic dry-run f|force k|keep negotiate-only prefetch p|prune q|quiet
+            pull: %w[4 6 n t a|append atomic dry-run f|force k|keep n|negotiate-only prefetch p|prune q|quiet
                      set-upstream unshallow update-shallow v|verbose deepen=i depth=i j|jobs=i negotiation-tip=q
-                     recurse-submodules=v refmap=q o|server-option=e shallow-exclude=e shallow-since=v
-                     upload-pack=e].freeze
+                     refmap=q o|server-option=q shallow-exclude=e shallow-since=b upload-pack=q].freeze
           }.freeze,
           log: {
             base: %w[all all-match alternate-refs author-date-order basic-regexp bisect boundary cherry cherry-mark
@@ -103,47 +172,54 @@ module Squared
                      first-parent F|fixed-strings follow full-diff full-history ignore-missing invert-grep left-only
                      merge log-size no-max-parents no-min-parents not P|perl-regexp reflog i|regexp-ignore-case
                      remove-empty reverse right-only simplify-by-decoration simplify-merges single-worktree show-pulls
-                     source sparse stdin topo-order g|walk-reflogs after=q ancestry-path=e? author=q before=q
+                     source sparse stdin topo-order g|walk-reflogs after=q ancestry-path=b? author=q before=q
                      branches=q? committer=q decorate=b decorate-refs=q decorate-refs-exclude=q exclude=q
                      exclude-hidden=b? glob=q grep=q grep-reflog=q L=q n|max-count=i max-parents=i min-parents=i
                      no-walk=b? remotes=q? since=q since-as-filter=q skip=i tags=q? until=q].freeze,
             format: %w[t children combined-all-paths oneline left-right no-diff-merges parents relative-date
-                       show-signature date=q diff-merges=b encoding=b expand-tabs=i format=q notes=b pretty=q?
+                       show-signature date=q diff-merges=b encoding=b expand-tabs=i format=q notes=q pretty=q?
                        show-linear-break=q?].freeze,
             diff: %w[p R u z l=i G=q O=q S=q binary check compact-summary cumulative find-copies-harder full-index
                      W|function-context w|ignore-all-space ignore-blank-lines ignore-cr-at-eol ignore-space-at-eol
                      b|ignore-space-change D|irreversible-delete graph ita-invisible-in-index minimal name-only
                      name-status no-color-moved-ws no-prefix no-renames numstat patch-with-raw patch-with-stat patience
-                     pickaxe-all pickaxe-regex raw shortstat summary a|text abbrev=i? anchored=q B|break-rewrites=e?
-                     color=b color-moved=b color-moved-ws=b color-words=q? diff-algorithm=b diff-filter=e? X|dirstat=b?
-                     dirstat-by-file=q? dst-prefix=q C|find-copies=b? find-object=e M|find-renames=b?
+                     pickaxe-all pickaxe-regex raw shortstat summary a|text abbrev=i? anchored=q B|break-rewrites=b?
+                     color=b color-moved=b color-moved-ws=b color-words=q? diff-algorithm=b diff-filter=e? X|dirstat=q?
+                     dirstat-by-file=q? dst-prefix=q C|find-copies=i? find-object=b M|find-renames=i?
                      I|ignore-matching-lines=q ignore-submodules=b inter-hunk-context=i line-prefix=q output=p
                      output-indicator-context=q output-indicator-new=q output-indicator-old=q relative=p rotate-to=p
                      skip-to=p src-prefix=q stat=q? stat-width=i stat-name-width=i stat-count=i submodule=b? U|unified=i
-                     word-diff=b? word-diff-regex=q ws-error-highlight=b].freeze
+                     word-diff=b? word-diff-regex=q ws-error-highligt=q].freeze
           }.freeze,
-          ls_files: %w[f t v z debug deduplicate directory eol error-unmatch exclude-standard full-name i|ignored
-                       k|killed no-empty-directory recurse-submodules sparse s|stage u|unmerged abbrev=i x|exclude=q
+          ls_files: %w[z debug deduplicate directory eol error-unmatch exclude-standard full-name k|killed
+                       no-empty-directory recurse-submodules sparse s|stage u|unmerged abbrev=i x|exclude=q
                        X|exclude-from=p exclude-per-directory=p format=q with-tree=q].freeze,
-          ls_remote: %w[exit-code get-url q|quiet o|server-option=e symref sort=q upload-pack=e].freeze,
-          pull: %w[e n allow-unrelated-histories ff-only S|gpg-sign=b? log=i r|rebase=v? s|strategy=b
-                   X|strategy-option=e].freeze,
+          ls_remote: %w[exit-code get-url q|quiet o|server-option=q symref sort=q upload-pack=q].freeze,
+          mv: %w[k f|force n|dry-run v|verbose].freeze,
+          pull: %w[e n allow-unrelated-histories ff-only S|gpg-sign=qq log=i r|rebase=b? s|strategy=b
+                   X|strategy-option=b].freeze,
+          merge: %w[e n allow-unrelated-histories ff-only m=q q|quiet v|verbose cleanup=b F|file=p S|gpg-sign=qq
+                    into-name=e log=i s|strategy=b X|strategy-option=b].freeze,
           rebase: %w[n C=i allow-empty-message apply committer-date-is-author-date edit-todo f|force-rebase ignore-date
-                     ignore-whitespace i|interactive keep-base m|merge no-ff q|quiet quit r|rebase-merges=b?
-                     reset-author-date root show-current-patch signoff v|verbose empty=b S|gpg-sign=b? onto=e
-                     s|strategy=b X|strategy-option=b whitespace=e].freeze,
+                     ignore-whitespace i|interactive keep-base m merge no-ff q|quiet quit r|rebase-merges=b?
+                     reset-author-date root show-current-patch signoff v|verbose empty=b S|gpg-sign=qq onto=e
+                     s|strategy=b X|strategy-option=b whitespace=b].freeze,
           reset: %w[N pathspec-file-nul q|quiet pathspec-from-file=p].freeze,
           restore: %w[ignore-unmerged ignore-skip-worktree-bits m|merge ours p|patch pathspec-file-nul S|staged theirs
                       W|worktree conflict=b pathspec-from-file=p s|source=q].freeze,
+          revert: %w[e abort continue no-commit quit reference skip cleanup=b S|gpg-sign=qq m|mainline=i s|signoff
+                     strategy=b X|strategy-option=b].freeze,
           rev_parse: {
             output: %w[absolute-git-dir all flags git-common-dir git-dir is-bare-repository is-inside-git-dir
-                       is-inside-work-tree is-shallow-repository local-env-vars no-flags no-revs not q|quiet revs-only
-                       shared-index-path show-cdup show-prefix show-toplevel show-superproject-working-tree sq sq-quote
-                       symbolic symbolic-full-name verify abbrev-ref=b? after=q before=q default=e disambiguate=b
-                       exclude=q exclude-hidden=b glob=q git-path=p path-format=b? prefix=q branches=q? remotes=q?
-                       resolve-git-dir=p short=i? show-object-format=b? since=q tags=q? until=q].freeze,
+                       is-inside-work-tree is-shallow-repository local-env-vars no-flags no-revs not q|quiet sq
+                       revs-only shared-index-path show-cdup show-prefix show-toplevel show-superproject-working-tree
+                       sq-quote symbolic symbolic-full-name verify abbrev-ref=b? after=q before=q default=q
+                       disambiguate=b exclude=q exclude-hidden=b glob=q git-path=p path-format=b? prefix=q branches=q?
+                       remotes=q? resolve-git-dir=p short=i? show-object-format=b? since=q tags=q? until=q].freeze,
             parseopt: %w[keep-dashdash stop-at-non-option stuck-long].freeze
           }.freeze,
+          rm: %w[r cached f|force n|dry-run ignore-unmatch pathspec-file-nul q|quiet sparse v|verbose
+                 pathspec-from-file=p].freeze,
           show: %w[t combined-all-paths no-diff-merges remerge-diff show-signature diff-merges=b encoding=b
                    expand-tabs=i notes=q show-notes=q?].freeze,
           stash: {
@@ -153,7 +229,8 @@ module Squared
             pop: %w[index].freeze,
             apply: %w[index].freeze
           }.freeze,
-          tag: %w[create-reflog column=b contains=e? format=q merged=e? n=i no-contains=e? no-merged=e? points-at=q
+          status: %w[untracked-files=b? u|ignore-submodules=m? ignored=b?],
+          tag: %w[create-reflog column=b contains=b? format=q merged=b? n=i no-contains=b? no-merged=b? points-at=q
                   sort=q].freeze,
           no: {
             fetch: {
@@ -169,20 +246,26 @@ module Squared
             tag: %w[column].freeze,
             branch: %w[color-moved column color track].freeze,
             checkout: %w[overwrite-ignore guess overlay progress recurse-submodules track].freeze,
+            merge: %w[autostash edit ff gpg-sign log progress overwrite-ignore rerere-autoupdate signoff squash stat
+                      verify verify-signatures].freeze,
             rebase: %w[autosquash autostash fork-point gpg-sign keep-empty reapply-cherry-picks reschedule-failed-exec
                        rerere-autoupdate stat update-refs verify].freeze,
             reset: %w[refresh].freeze,
             restore: %w[overlay progress recurse-submodules].freeze,
+            revert: %w[edit gpg-sign rerere-autoupdate].freeze,
             show: %w[standard-notes].freeze
           }.freeze
-        }
+        }.freeze
         VAL_GIT = {
+          merge: {
+            send: %w[continue abort quit].freeze
+          }.freeze,
           rebase: {
             send: %w[continue skip abort quit].freeze,
             value: %w[true false merges interactive].freeze
           }.freeze,
           reset: %w[soft mixed hard merge keep recurse-submodules no-recurse-submodules].freeze
-        }
+        }.freeze
         private_constant :OPT_GIT, :VAL_GIT
 
         class << self
@@ -214,7 +297,7 @@ module Squared
           end
 
           def tasks
-            %i[pull rebase fetch clone stash status].freeze
+            %i[pull rebase fetch clone stash status branch revbuild].freeze
           end
 
           def batchargs
@@ -232,24 +315,25 @@ module Squared
           'branch' => %i[create set delete move copy list edit current].freeze,
           'checkout' => %i[commit branch track detach path].freeze,
           'commit' => %i[add all amend amend-orig].freeze,
-          'diff' => %i[head cached branch files view between contain].freeze,
+          'diff' => %i[head branch files view between contain].freeze,
           'fetch' => %i[origin remote].freeze,
-          'files' => %i[cached modified deleted others].freeze,
+          'files' => %i[cached modified deleted others ignored].freeze,
+          'git' => %i[clean mv restore revert rm].freeze,
           'log' => %i[view between contain].freeze,
+          'merge' => %i[commit no-commit send].freeze,
           'pull' => %i[origin remote].freeze,
           'rebase' => %i[branch onto send].freeze,
           'refs' => %i[heads tags remote].freeze,
           'reset' => %i[commit index patch mode].freeze,
-          'restore' => %i[source worktree staged overlay].freeze,
-          'rev' => %i[commit branch output parseopt].freeze,
+          'rev' => %i[commit branch output parseopt build].freeze,
           'show' => %i[format oneline].freeze,
-          'stash' => %i[push pop apply drop clear list].freeze,
+          'stash' => %i[push pop apply drop list].freeze,
           'tag' => %i[add delete list].freeze
         }.freeze
 
         def initialize(*, **)
           super
-          initialize_ref(Git.ref) if gitpath.exist?
+          initialize_ref Git.ref if gitpath.exist?
         end
 
         def ref
@@ -294,19 +378,6 @@ module Squared
                         commit(flag, refs: refs)
                       end
                     end
-                  when 'restore'
-                    if flag == :source
-                      format_desc action, flag, 'tree,opts*,pathspec*'
-                      task flag, [:tree] do |_, args|
-                        tree = param_guard(action, flag, args: args, key: :tree)
-                        restore(flag, args.extras, tree: tree)
-                      end
-                    else
-                      format_desc action, flag, 'opts*,pathspec+'
-                      task flag do |_, args|
-                        restore flag, args.to_a
-                      end
-                    end
                   when 'tag'
                     case flag
                     when :list
@@ -340,9 +411,19 @@ module Squared
                     case flag
                     when :view, :between, :contain
                       if flag == :view && action == 'log'
-                        format_desc action, flag, '(^)commit*,pathspec*,opts*'
+                        format_desc action, flag, '(^)commit/H0*,pathspec*,opts*'
                         task flag do |_, args|
-                          logx flag, args.to_a
+                          index = []
+                          args.to_a.each do |val|
+                            if val =~ /^H(\d+)$/
+                              index << "HEAD~#{$1}"
+                            elsif (sha = commithash(val))
+                              index << sha
+                            elsif val.start_with?('^') || (!%r{^[.\\/]}.match?(val) && !%r{[\\/]$}.match?(val))
+                              index << shell_quote(val)
+                            end
+                          end
+                          logx(flag, args.to_a.drop(index.size), index: index)
                         end
                       else
                         format_desc action, flag, 'commit1,commit2,pathspec*,opts*'
@@ -352,10 +433,16 @@ module Squared
                           __send__(action == 'log' ? :logx : :diff, flag, args.extras, range: [commit1, commit2])
                         end
                       end
-                    when :head, :cached
-                      format_desc action, flag, 'opts*,pathspec*'
+                    when :head
+                      format_desc action, flag, 'commit/H0*,opts*,pathspec*'
                       task flag do |_, args|
-                        diff flag, args.to_a
+                        index = []
+                        args.to_a.each do |val|
+                          break unless val =~ /^H(\d+)$/ || (sha = commithash(val))
+
+                          index << ($1 ? "HEAD~#{$1}" : sha)
+                        end
+                        diff(flag, args.to_a.drop(index.size), index: index)
                       end
                     when :branch
                       format_desc action, flag, 'name,opts*,pathspec*'
@@ -406,7 +493,7 @@ module Squared
                       format_desc action, flag, 'branch/commit,opts*'
                       task flag, [:commit] do |_, args|
                         commit = param_guard(action, flag, args: args, key: :commit)
-                        checkout(flag, args.extras, commit: commit)
+                        checkout(flag, commit: commit)
                       end
                     when :detach
                       format_desc action, flag, 'branch/commit?'
@@ -500,7 +587,7 @@ module Squared
                         show args.format, args.extras
                       end
                     end
-                  when 'rebase'
+                  when 'rebase', 'merge'
                     case flag
                     when :branch
                       format_desc action, flag, 'opts*,upstream?,branch?'
@@ -515,11 +602,18 @@ module Squared
                         upstream = param_guard(action, flag, args: args, key: :upstream)
                         rebase(flag, commit: commit, upstream: upstream, branch: args.branch)
                       end
+                    when :commit, :'no-commit'
+                      format_desc action, flag, 'branch/commit+,opts*'
+                      task flag do |_, args|
+                        args = param_guard(action, flag, args: args.to_a)
+                        merge flag, args
+                      end
                     when :send
-                      format_desc(action, flag, VAL_GIT[:rebase][:send], arg: nil)
+                      format_desc(action, flag, VAL_GIT[action.to_sym][:send], arg: nil)
                       task flag, [:command] do |_, args|
-                        command = param_guard(action, flag, args: args, key: :command)
-                        rebase(flag, command: command)
+                        command = param_guard(action, flag, args: args, key: :command,
+                                                            values: VAL_GIT[action.to_sym][:send])
+                        __send__(action, flag, command: command)
                       end
                     end
                   when 'rev'
@@ -540,6 +634,11 @@ module Squared
                       task flag, [:ref] do |_, args|
                         rev_parse(flag, ref: args.ref)
                       end
+                    when :build
+                      format_desc action, flag, OPT_GIT[:status]
+                      task flag do |_, args|
+                        revbuild flag, args.to_a
+                      end
                     else
                       format_desc action, flag, 'opts*,args*'
                       task flag do |_, args|
@@ -551,7 +650,7 @@ module Squared
                       format_desc action, flag, 'remote,opts*,pattern*'
                       task flag, [:remote] do |_, args|
                         remote = param_guard(action, flag, args: args, key: :remote)
-                        ls_remote(flag, args.extras, remote: remote)
+                        ls_remote(flag, args.to_a.drop(1), remote: remote)
                       end
                     else
                       format_desc action, flag, 'opts*,pattern*'
@@ -559,6 +658,18 @@ module Squared
                         __send__(action == 'refs' ? :ls_remote : :ls_files, flag, args.to_a)
                       end
                     end
+                  when 'git'
+                    format_desc(action, flag, 'opts*', before: case flag
+                                                               when :rm
+                                                                 'source+,destination'
+                                                               when :revert
+                                                                 'commit+'
+                                                               else
+                                                                 'pathspec*'
+                                                               end)
+                    task flag do |_, args|
+                      git(flag, args.to_a)
+                    end
                   end
                 end
               end
@@ -571,12 +682,19 @@ module Squared
           super
         end
 
+        def depend(*, **)
+          workspace.rev_clear name
+          super
+        end
+
+        def clean(*, **)
+          workspace.rev_clear name
+          super
+        end
+
         def pull(flag = nil, opts = [], sync: invoked_sync?('pull', flag), remote: nil)
-          cmd = git_session 'pull'
-          if flag == :rebase
-            cmd << '--rebase'
-            cmd << '--autostash' if option('autostash')
-          elsif (val = option('rebase', ignore: false))
+          cmd, opts = git_session('pull', flag && "--#{flag}", opts: opts)
+          if (val = option('rebase', ignore: false))
             cmd << case val
                    when '0'
                      '--no-rebase'
@@ -588,8 +706,8 @@ module Squared
                       no: OPT_GIT[:no][:pull] + OPT_GIT[:no][:fetch][:pull], remote: remote, flag: flag)
           source(sync: sync, sub: if verbose
                                     [
-                                      { pat: /^(.+)(\|\s+\d+\s+)([^-]*)(-+)(.*)$/, styles: :red, index: 4 },
-                                      { pat: /^(.+)(\|\s+\d+\s+)(\++)(-*)(.*)$/, styles: :green, index: 3 }
+                                      { pat: /^(.+)(\|\s+\d+\s+)([^-]*)(-+)(.*)$/, styles: color(:red), index: 4 },
+                                      { pat: /^(.+)(\|\s+\d+\s+)(\++)(-*)(.*)$/, styles: color(:green), index: 3 }
                                     ]
                                   end, **threadargs)
         end
@@ -598,7 +716,7 @@ module Squared
                    command: nil)
           return pull(:rebase, sync: sync) unless flag
 
-          cmd = git_session 'rebase'
+          cmd, opts = git_session('rebase', opts: opts)
           case flag
           when :branch
             branch = option_sanitize(opts, OPT_GIT[:rebase], no: OPT_GIT[:no][:rebase]).first
@@ -627,7 +745,7 @@ module Squared
         end
 
         def fetch(flag = nil, opts = [], sync: invoked_sync?('fetch', flag), remote: nil)
-          cmd = git_session 'fetch'
+          cmd, opts = git_session('fetch', opts: opts)
           cmd << '--all' if !remote && !opts.include?('multiple') && option('all')
           cmd << '--verbose' if verbose && !opts.include?('quiet')
           append_pull(opts, collect_hash(OPT_GIT[:fetch]), no: collect_hash(OPT_GIT[:no][:fetch]),
@@ -659,22 +777,14 @@ module Squared
 
         def stash(flag = nil, opts = [], sync: invoked_sync?('stash', flag))
           if flag
-            cmd = git_session 'stash', flag
-            list = OPT_GIT[:stash][:common] + OPT_GIT[:stash].fetch(flag, [])
-            refs = option_sanitize(opts, list).first
+            cmd, opts = git_session('stash', flag, opts: opts)
+            refs = option_sanitize(opts, OPT_GIT[:stash][:common] + OPT_GIT[:stash].fetch(flag, [])).first
             case flag
             when :push
               append_pathspec refs
             when :pop, :apply, :drop
-              unless refs.empty?
-                cmd << shell_escape(refs.pop)
-                option_clear refs
-              end
-            when :clear
-              if confirm("Remove #{sub_style('all', styles: theme[:active])} the stash entries? [y/N] ", 'N')
-                source(stdout: true)
-              end
-              return
+              cmd << shell_quote(refs.pop)
+              option_clear refs
             when :list
               out, banner, from = source(io: true)
               print_item banner
@@ -683,17 +793,16 @@ module Squared
               return
             end
           else
-            git_session 'stash', 'push'
+            git_session('stash', 'push', opts: opts)
             append_option(%w[all keep-index include-untracked staged].freeze, no: true, ignore: false)
             append_message option('message', 'm', ignore: false)
           end
           source(banner: !quiet?, sync: sync, **threadargs)
         end
 
-        def status(*, sync: invoked_sync?('status'), **)
+        def status(*)
           cmd = git_session 'status'
           cmd << (option('long') ? '--long' : '--short')
-          cmd << '--branch' if option('branch')
           if (val = option('ignore-submodules', ignore: false))
             cmd << basic_option('ignore-submodules', case val
                                                      when '0', 'none'
@@ -708,31 +817,85 @@ module Squared
           end
           append_pathspec
           out, banner, from = source(io: true)
-          if sync
-            print_item banner
-            banner = nil
-          end
           ret = write_lines(out, banner: banner, sub: if verbose
+                                                        r = color(:red)
+                                                        g = color(:green)
                                                         [
-                                                          { pat: /^(.)([A-Z?!])(.+)$/, styles: :red, index: 2 },
-                                                          { pat: /^([A-Z?!])(.+)$/, styles: :green },
-                                                          { pat: /^(\?\?)(.+)$/, styles: :red },
+                                                          { pat: /^(.)([A-Z?!])(.+)$/, styles: r, index: 2 },
+                                                          { pat: /^([A-Z?!])(.+)$/, styles: g },
+                                                          { pat: /^(\?\?)(.+)$/, styles: r },
                                                           { pat: /^(## )(.+)(\.{3})(.+)$/,
-                                                            styles: [nil, :green, nil, :red], index: -1 }
+                                                            styles: [nil, g, nil, r], index: -1 }
                                                         ]
                                                       end)
           list_result(ret, 'files', from: from, action: 'modified')
         end
 
+        def revbuild(flag = nil, opts = [], sync: invoked_sync?('revbuild', flag), **kwargs)
+          statusargs = lambda do
+            {
+              include: relativepath(as_a(kwargs[:include]), all: true),
+              exclude: relativepath(as_a(kwargs[:exclude]), all: true)
+            }
+          end
+          unless workspace.closed
+            if @revbuild
+              statusargs.().each { |key, val| @revbuild[key] += val }
+            else
+              @revbuild = statusargs.()
+            end
+            return
+          end
+          sha = source(git_output('rev-parse --verify HEAD'), io: true, banner: false, stdout: true).first.to_s.chomp
+          return if sha.empty?
+
+          args = []
+          kwargs = kwargs.key?(:include) || kwargs.key?(:exclude) ? statusargs.() : @revbuild || {}
+          case flag
+          when :build
+            opts = option_sanitize(opts, OPT_GIT[:status], target: args).first
+            option_clear opts
+          else
+            args << basic_option('untracked-files', flag) if (flag = option('untracked-files', prefix: 'git'))
+            args << basic_option('ignore-submodules', flag) if (flag = option('ignore-submodules', prefix: 'git'))
+            args << basic_option('ignored', flag) if (flag = option('ignored', prefix: 'git'))
+          end
+          if (cur = workspace.rev_entry(name)) && cur['revision'] == sha
+            files = status_digest(*args, **kwargs)
+            if cur['files'].size == files.size && cur['files'].find { |key, val| files[key] != val }.nil?
+              if verbose
+                if (since = workspace.rev_timesince(name, 'build'))
+                  puts log_message(Logger::INFO, name, 'no changes', subject: 'revbuild', hint: "#{since} ago")
+                else
+                  workspace.rev_timeutc(name, 'build')
+                end
+              end
+              return
+            end
+          end
+          start = epochtime
+          build(@output, sync: sync, from: :'git:revbuild')
+        rescue StandardError => e
+          warn log_message(Logger::WARN, e, pass: true) if warning?
+        else
+          if verbose
+            msg = sub_style('completed', styles: theme[:active])
+            puts log_message(Logger::INFO, name, msg, subject: 'revbuild', hint: time_format(epochtime - start))
+          end
+          workspace.rev_write(name, { 'revision' => sha, 'files' => status_digest(*args, **kwargs) }, utc: 'build')
+        end
+
         def reset(flag, opts = [], refs: nil, ref: nil, mode: nil, commit: nil)
-          cmd = git_session 'reset'
+          cmd, opts = git_session('reset', opts: opts)
           case flag
           when :commit, :index
-            refs = option_sanitize(opts, OPT_GIT[:reset] + VAL_GIT[:reset], no: OPT_GIT[:no][:reset]).first
+            out = option_sanitize(opts, OPT_GIT[:reset] + VAL_GIT[:reset], no: OPT_GIT[:no][:reset]).first
             if flag == :commit
-              append_value commit
-              option_clear refs
+              append_value(commit, delim: true)
+              option_clear out
               ref = false
+            else
+              (refs ||= []).concat(out)
             end
           when :mode
             return unless VAL_GIT[:reset].include?(mode)
@@ -748,21 +911,19 @@ module Squared
             return
           end
           unless ref == false
-            append_commit ref
+            append_commit(ref, head: true)
             append_pathspec refs if refs
           end
           source
         end
 
         def checkout(flag, opts = [], branch: nil, origin: nil, create: nil, commit: nil, detach: nil)
-          cmd = git_session 'checkout'
+          cmd, opts = git_session('checkout', opts: opts)
           append_option 'force', 'merge'
           case flag
           when :branch
             cmd << '--detach' if detach == 'd' || option('detach')
-            if (val = option('track'))
-              cmd << shell_option('track', val)
-            end
+            append_option('track', equals: true)
             cmd << if create
                      shell_option(create, branch)
                    else
@@ -783,7 +944,7 @@ module Squared
           else
             out = option_sanitize(opts, OPT_GIT[:checkout], no: OPT_GIT[:no][:checkout]).first
             if flag == :commit
-              append_value commit
+              append_value(commit, delim: true)
               option_clear out
             else
               append_head
@@ -794,7 +955,7 @@ module Squared
         end
 
         def tag(flag, opts = [], refs: [], message: nil, commit: nil)
-          cmd = git_session 'tag'
+          cmd, opts = git_session('tag', opts: opts)
           case flag
           when :add
             if option('sign')
@@ -802,8 +963,8 @@ module Squared
             elsif !session_arg?('s', 'sign', 'u', 'local-user')
               cmd << '--annotate'
             end
-            if !commit && message && (hash = commithash(message))
-              commit = hash
+            if !commit && message && (sha = commithash(message))
+              commit = sha
             else
               append_message message
             end
@@ -826,41 +987,27 @@ module Squared
           source
         end
 
-        def logx(flag, opts = [], range: [])
-          cmd = git_session 'log'
-          files = option_sanitize(opts, collect_hash(OPT_GIT[:log]), no: collect_hash(OPT_GIT[:no][:log])).first
+        def logx(flag, opts = [], range: [], index: [])
+          cmd, opts = git_session('log', opts: opts)
+          refs = option_sanitize(opts, collect_hash(OPT_GIT[:log]), no: collect_hash(OPT_GIT[:no][:log])).first
           case flag
           when :between, :contain
             cmd << shell_quote(range.join(flag == :between ? '..' : '...'))
           else
-            commit, files = files.partition do |val|
-              val.start_with?('^') || (!%r{^.(?:[\\/]|$)}.match?(val) && !%r{[\\/]$}.match?(val)) || commithash(val)
-            end
-            cmd.merge(commit.map { |val| commithash(val) || shell_quote(val) }) unless commit.empty?
+            cmd.merge(index)
           end
           append_nocolor
-          append_pathspec files
+          append_pathspec refs
           source(exception: false)
         end
 
-        def diff(flag, opts = [], refs: [], branch: nil, range: [])
-          cmd = git_session 'diff'
+        def diff(flag, opts = [], refs: [], branch: nil, range: [], index: [])
+          cmd, opts = git_session('diff', opts: opts)
           files = option_sanitize(opts, collect_hash(OPT_GIT[:diff]) + OPT_GIT[:log][:diff],
                                   no: OPT_GIT[:no][:log][:diff]).first
           case flag
           when :files, :view, :between, :contain
             cmd.delete('--cached')
-          else
-            items = files.dup
-            sha = nil
-            files.clear
-            items.each do |val|
-              if (s = commithash(val))
-                (sha ||= []).push(s)
-              else
-                files << val
-              end
-            end
           end
           append_nocolor
           if flag == :files
@@ -875,15 +1022,14 @@ module Squared
               cmd.delete('--merge-base')
               cmd << shell_quote(range.join(flag == :between ? '..' : '...'))
             else
-              cmd << '--cached' if flag == :cached
               cmd << '--merge-base' if option('merge-base')
               cmd << shell_quote(branch) if branch
-              if sha
+              if !index.empty?
                 if session_arg?('cached')
-                  raise_error('diff', sha.join(', '), hint: 'one commit') if sha.size > 1
-                  cmd << sha.first
+                  raise_error("one commit only: #{index.join(', ')}", hint: '--cached') if index.size > 1
+                  cmd << index.first
                 else
-                  cmd.merge(sha)
+                  cmd.merge(index)
                 end
               elsif (n = option('index'))
                 cmd << "HEAD~#{n}"
@@ -900,48 +1046,61 @@ module Squared
           if !message && !amend
             return if pass
 
-            raise_error('commit', 'GIT_MESSAGE="description"', hint: 'missing')
+            raise_error('missing message', hint: 'GIT_MESSAGE="description"')
           end
           pathspec = if flag == :all || (amend && refs.size == 1 && refs.first == '*')
                        '--all'
                      elsif (refs = projectmap(refs)).empty?
-                       raise_error('commit', 'pathspec', hint: 'missing')
+                       raise_error 'no qualified pathspec'
                      else
                        "-- #{refs.join(' ')}"
                      end
-          format = '%(if)%(HEAD)%(then)%(refname:short)...%(upstream:short)...%(upstream:track)%(end)'
-          branch = nil
           origin = nil
-          source(git_output('fetch --no-tags --quiet'), io: true, banner: false, stdout: true)
-          cmd = git_output("for-each-ref --format=\"#{format}\" refs/heads")
-          source(cmd, io: true, banner: false).first.each do |line|
-            next if (line = line.chomp).empty?
-
-            branch, origin, hint = line.split('...')
-            if hint && !hint.match?(/^\[(\D+0,\D+0)\]$/)
-              raise_error('work tree is not usable', hint: hint[1..-2])
-            elsif origin.empty?
-              return nil if pass
-
-              raise_error('no remote upstream', hint: branch)
+          branch = nil
+          upstream = nil
+          source(git_output('fetch --no-tags --quiet'), io: true, banner: false)
+          source(git_output('branch -vv --list'), io: true, banner: false).first.each do |val|
+            next unless (r = /^\*\s(\S+)\s+(\h+)(?:\s\[(.+?)(?=\]\s)\])?\s/.match(val))
+
+            branch = r[1]
+            if r[3]
+              origin = r[3][%r{^(.+)/#{Regexp.escape(branch)}$}, 1]
+            else
+              unless (origin = option('repository', prefix: 'git', ignore: false))
+                out = source(git_output('log -n1 --format=%h%d'), io: true, banner: false, stdout: true).first
+                if out =~ /^#{r[2]} \(HEAD -> #{Regexp.escape(branch)}, (.+?)\)$/
+                  split_escape($1).each do |val|
+                    next unless val.end_with?("/#{branch}")
+
+                    origin = val[0, val.size - branch.size - 1]
+                    break
+                  end
+                end
+              end
+              upstream = true if origin
             end
             break
           end
-          i = origin.index('/')
-          branch = "#{branch}:#{origin[i + 1..-1]}" unless origin.end_with?("/#{branch}")
-          origin = origin[0..i - 1]
+          raise_error 'work tree is not usable' unless origin && branch
           cmd = git_session('commit', option('dry-run') && '--dry-run', options: false)
-          cmd << '--amend' if amend
+          if amend
+            cmd << '--amend'
+          else
+            cmd.delete('--amend')
+          end
           if message
             append_message message
           elsif flag == :'amend-orig' || option('no-edit')
             cmd << '--no-edit'
           end
           a = git_output 'add', '--verbose'
-          b = git_output 'push'
-          b << '--dry-run' if dryrun?
+          b = git_output 'push', upstream && '--set-upstream'
+          if dryrun?
+            a << '--dry-run'
+            b << '--dry-run'
+          end
           a << pathspec
-          b << '--force-with-lease' if amend
+          b << '--force' if amend
           b << origin << branch
           puts if pass
           source a
@@ -949,8 +1108,24 @@ module Squared
           source b
         end
 
-        def branch(flag, opts = [], refs: [], ref: nil, target: nil)
-          cmd = git_session 'branch'
+        def merge(flag, opts = [], command: nil)
+          cmd, opts = git_session('merge', opts: opts)
+          case flag
+          when :commit, :'no-commit'
+            refs = option_sanitize(opts, OPT_GIT[:merge], no: OPT_GIT[:no][:merge]).first
+            raise_error 'no branch/commit' if refs.empty?
+            cmd << "--#{flag}" << '--'
+            append_commit(*refs)
+          else
+            return unless VAL_GIT[:merge][:send].include?(command)
+
+            cmd << "--#{command}"
+          end
+          source
+        end
+
+        def branch(flag = nil, opts = [], refs: [], ref: nil, target: nil)
+          cmd, opts = git_session('branch', opts: opts)
           stdout = false
           case flag
           when :create
@@ -969,7 +1144,7 @@ module Squared
             return unless ref
 
             if ref.start_with?('^')
-              cmd << '--unset-upstream' << shell_escape(ref[1..-1])
+              cmd << '--unset-upstream' << shell_escape(arg[1..-1])
               target = nil
               stdout = true
             else
@@ -977,7 +1152,7 @@ module Squared
             end
             ref = nil
           when :delete
-            force, list = refs.partition { |val| val =~ /^[\^~]/ }
+            force, list = refs.partition { |val| val.match?(/^[\^~]/) }
             force.each do |val|
               dr = val[0, 3]
               d = dr.include?('^') ? '-D' : '-d'
@@ -997,10 +1172,9 @@ module Squared
             cmd << '--edit-description'
           when :current
             cmd << '--show-current'
-          else
-            opts = option_sanitize(opts, OPT_GIT[:branch], no: OPT_GIT[:no][:branch]).first
+          when :list
             grep = []
-            opts.each do |opt|
+            option_sanitize(opts, OPT_GIT[:branch], no: OPT_GIT[:no][:branch]).first.each do |opt|
               if opt =~ /^(v+)$/
                 cmd << "-#{$1}"
               else
@@ -1012,42 +1186,46 @@ module Squared
             out, banner, from = source(io: true)
             print_item banner
             ret = write_lines(out, sub: [
-              { pat: /^(\*\s+)(\S+)(\s*)$/, styles: :green, index: 2 },
-              { pat: %r{^(\s*)(remotes/\S+)(.*)$}, styles: :red, index: 2 }
+              { pat: /^(\*\s+)(\S+)(\s*)$/, styles: color(:green), index: 2 },
+              { pat: %r{^(\s*)(remotes/\S+)(.*)$}, styles: color(:red), index: 2 }
             ])
             list_result(ret, 'branches', from: from)
             return
+          else
+            head = source(git_output('rev-parse --abbrev-ref HEAD'), io: true, banner: false, stdout: true).first.chomp
+            if head.empty?
+              ret = 0
+            else
+              out, banner, from = source(cmd << '-vv --no-abbrev --list', io: true)
+              ret = write_lines(out, grep: /^\*\s+#{Regexp.escape(head)}\s/, banner: banner, first: true) do |line|
+                next line if stdin?
+
+                data = line.sub(/^\*\s+/, '').split(/\s+/)
+                a = sub_style(data[0], styles: theme[:inline])
+                b = sub_style(data[1], styles: theme[:extra])
+                r = /\A(?:\[(.+?)(?=\]\s)\]\s)?(.+)\z/m.match(data[2..-1].join(' '))
+                [" Branch: #{a + (r[1] ? " (#{r[1]})" : '')}", " Commit: #{b}", "Message: #{r[2]}"].compact.join("\n")
+              end
+              on :last, from
+            end
+            if ret == 0
+              warn log_message(Logger::WARN, name, 'no ref found', subject: 'branch', hint: 'head', pass: true)
+            end
+            return
           end
           cmd << shell_escape(target) if target
           cmd << shell_escape(ref) if ref
           source(stdout: stdout)
         end
 
-        def restore(flag, opts = [], tree: nil)
-          cmd = git_session 'restore'
-          refs = option_sanitize(opts, OPT_GIT[:restore], no: OPT_GIT[:no][:restore]).first
-          if flag == :source
-            cmd << '--patch' if refs.empty?
-            cmd << shell_option('source', tree)
-          else
-            cmd << "--#{flag}"
-          end
-          if session_arg?('p', 'patch')
-            option_clear refs
-          else
-            append_pathspec(refs, expect: true)
-          end
-          source(sync: false, stderr: true)
-        end
-
         def show(format, opts = [])
-          cmd = git_session 'show'
+          cmd, opts = git_session('show', opts: opts)
           if format
             case (val = format.downcase)
             when 'oneline', 'short', 'medium', 'full', 'fuller', 'reference', 'email', 'raw'
               cmd << basic_option('format', val)
             else
-              if format =~ /^t?format:/ || format.include?('%')
+              if format.match?(/^t?format:/) || format.include?('%')
                 cmd << quote_option('pretty', format)
               else
                 opts << format
@@ -1065,18 +1243,19 @@ module Squared
         end
 
         def rev_parse(flag, opts = [], ref: nil, size: nil)
-          cmd = git_session 'rev-parse', if flag == :parseopt
-                                           '--parseopt'
-                                         elsif opts.delete('sq-quote')
-                                           '--sq-quote'
-                                         end
+          cmd, opts = git_session('rev-parse', opts: opts)
+          cmd << if flag == :parseopt
+                   '--parseopt'
+                 elsif opts.delete('sq-quote')
+                   '--sq-quote'
+                 end
           case flag
           when :commit
             cmd << ((n = size.to_i) > 0 ? basic_option('short', [n, 5].max) : '--verify')
-            append_commit ref
+            append_commit(ref, head: true)
           when :branch
             cmd << '--abbrev-ref'
-            append_commit ref
+            append_commit(ref, head: true)
           else
             args = option_sanitize(opts, OPT_GIT[:rev_parse][flag]).first
             append_value(args, escape: session_arg?('sq-quote'))
@@ -1085,7 +1264,7 @@ module Squared
         end
 
         def ls_remote(flag, opts = [], remote: nil)
-          cmd = git_session 'ls-remote', '--refs'
+          cmd, opts = git_session('ls-remote', '--refs', opts: opts)
           cmd << "--#{flag}" unless flag == :remote
           grep = option_sanitize(opts, OPT_GIT[:ls_remote]).first
           cmd << shell_quote(remote) if remote
@@ -1096,7 +1275,7 @@ module Squared
         end
 
         def ls_files(flag, opts = [])
-          git_session 'ls-files', "--#{flag}"
+          opts = git_session('ls-files', "--#{flag}", opts: opts).last
           grep = option_sanitize(opts, OPT_GIT[:ls_files]).first
           out, banner, from = source(io: true)
           print_item banner
@@ -1104,10 +1283,51 @@ module Squared
           list_result(ret, 'files', from: from, grep: grep)
         end
 
+        def git(flag, opts = [])
+          cmd, opts = git_session(flag, opts: opts)
+          refs = option_sanitize(opts, OPT_GIT[flag], no: OPT_GIT[:no][flag]).first
+          refs = projectmap(refs) unless flag == :revert
+          sync = false
+          stderr = true
+          case flag
+          when :clean
+            unless refs.empty?
+              cmd << '--'
+              cmd.merge(refs)
+            end
+            sync = true
+            stderr = false
+          when :restore
+            if session_arg?('p', 'patch')
+              option_clear refs
+            else
+              append_pathspec(refs, expect: true)
+            end
+          when :revert
+            if VAL_GIT[:rebase][:send].any? { |val| session_arg?(val) }
+              option_clear refs
+            elsif refs.empty?
+              raise_error 'no commit given'
+            else
+              append_commit(*refs)
+            end
+          when :mv
+            raise_error 'no source/destination' unless refs.size > 1
+            cmd.merge(refs)
+          when :rm
+            append_pathspec(refs, expect: true)
+          end
+          source(sync: sync, stderr: stderr)
+        end
+
         def clone?
           ref?(workspace.baseref) && workspace.git_clone?(path, name) ? 1 : false
         end
 
+        def revbuild?
+          build? && !!workspace.revfile
+        end
+
         def enabled?(*, **kwargs)
           super || (kwargs[:base] == false && !!clone?)
         end
@@ -1120,7 +1340,7 @@ module Squared
           if cmd.respond_to?(:done)
             if io && banner == false
               from = nil
-            elsif !from && (from = cmd.drop(1).find { |val| val =~ /^[a-z][a-z\-]{2,}$/ })
+            elsif !from && (from = cmd.drop(1).find { |val| val.match?(/^[a-z][a-z\-]{2,}$/) })
               from = :"git:#{from}"
             end
             banner &&= cmd.temp { |val| val.start_with?('--work-tree') || val.start_with?('--git-dir') }
@@ -1166,13 +1386,13 @@ module Squared
             ret = on(:error, from, e)
             raise if exception && ret != true
 
-            warn log_message(Logger::WARN, e) if warning?
+            warn log_message(Logger::WARN, e, pass: true) if warning?
           else
             on :last, from
           end
         end
 
-        def write_lines(data, banner: nil, loglevel: nil, grep: nil, sub: nil, pass: false)
+        def write_lines(data, banner: nil, loglevel: nil, grep: nil, sub: nil, pass: false, first: false)
           grep = as_a(grep).map do |val|
             next val if val.is_a?(Regexp)
 
@@ -1185,6 +1405,7 @@ module Squared
           data.each do |line|
             next if grep&.none? { |pat| pat.match?(line) }
 
+            line = yield line if block_given?
             if loglevel
               log&.add loglevel, line
             else
@@ -1196,8 +1417,9 @@ module Squared
               end
             end
             ret += 1
+            break if first
           end
-          print_item banner, out if banner && (ret > 0 || !pass)
+          print_item banner, out if banner && (ret > 0 || (!pass && !first))
           ret
         end
 
@@ -1206,7 +1428,7 @@ module Squared
             if size > 0
               styles = theme.fetch(:banner, []).reject { |s| s.to_s.end_with?('!') }
               styles << :bold if styles.size <= 1
-              puts print_footer("#{size} #{size == 1 ? type.sub(/(?:(?<!l)e)?s\z/, '') : type}",
+              puts print_footer("#{size} #{size == 1 ? type.sub(/e?s\z/, '') : type}",
                                 sub: { pat: /\A(\d+)(.+)\z/, styles: styles })
             else
               puts empty_status("No #{type} were #{action}", 'grep', grep.is_a?(Array) ? case grep.size
@@ -1220,12 +1442,27 @@ module Squared
           on :last, from
         end
 
+        def status_digest(*args, algorithm: Digest::SHA256, **kwargs)
+          glob = kwargs.fetch(:include, [])
+          pass = kwargs.fetch(:exclude, [])
+          ret = {}
+          out = source(git_output('status -s --porcelain', *args), io: true, banner: false).first
+          out.each do |line|
+            next unless (file = line[/^[A-Z ?!]{3}"?(.+?)"?$/, 1])
+            next if !glob.empty? && glob.none? { |val| File.fnmatch?(val, file, File::FNM_DOTMATCH) }
+            next if !pass.empty? && pass.any? { |val| File.fnmatch?(val, file, File::FNM_DOTMATCH) }
+
+            ret[file] = algorithm.hexdigest(File.read(basepath(file)))
+          end
+          ret
+        end
+
         def append_pull(opts, list, target: @session, no: nil, flag: nil, remote: nil)
-          target << '--force' if option('force', target: target)
+          cmd << '--force' if option('force')
           rsm = append_submodules(target: target)
           out = []
           refspec = []
-          opts, pat = option_sanitize(opts, remote ? list + ['refspec=v'] : list, target: target, no: no)
+          opts, pat = option_sanitize(opts, remote ? list + ['refspec=b'] : list, target: target, no: no)
           opts.each do |opt|
             if opt =~ pat
               case $1
@@ -1246,7 +1483,7 @@ module Squared
           end
           if remote
             append_value(remote, target: target, delim: true)
-            if (val = option('refspec', target: target, strict: true))
+            if (val = option('refspec', strict: true))
               append_value(split_escape(val), target: target)
             else
               target.merge(refspec)
@@ -1259,23 +1496,27 @@ module Squared
           option_clear(out, target: target, subject: flag.to_s) if flag
         end
 
-        def append_commit(val, target: @session)
-          val = val.to_s.strip
-          target << (val.empty? ? append_head(target: target) || 'HEAD' : val)
+        def append_commit(*val, target: @session, head: false)
+          val.compact!
+          if !val.empty?
+            val.each { |ref| target << (commithash(ref) || shell_quote(ref)) }
+          elsif head
+            target << (append_head(target: target) || 'HEAD')
+          end
         end
 
         def append_pathspec(files = [], target: @session, expect: false, parent: false)
-          if session_arg?('pathspec-from-file', target: target)
+          if session_arg?('pathspec-from-file')
             option_clear files
           else
-            if files.empty? && (val = option('pathspec', target: target))
+            if files.empty? && (val = option('pathspec'))
               files = split_escape(val)
             end
             files = projectmap(files, parent: parent)
             if !files.empty?
-              target << "-- #{files.join(' ')}"
+              target << '--' << files.join(' ')
             elsif expect
-              raise_error(parent ? 'pathspec not present' : 'pathspec not within worktree', hint: 'invalid')
+              raise_error(parent ? 'pathspec not present' : 'pathspec not within worktree')
             end
           end
         end
@@ -1291,34 +1532,32 @@ module Squared
         end
 
         def append_submodules(from = nil, target: @session)
-          return unless (val = option('recurse-submodules', target: target, ignore: false))
+          return unless (val = option('recurse-submodules', ignore: false))
 
           if from == :clone
-            case val
-            when '0', 'false'
-              target << '--no-recurse-submodules'
-            when '1', 'true'
-              target << '--recurse-submodules'
-            else
-              projectmap(split_escape(val)).each do |path|
-                target << basic_option('recurse-submodules', path)
-              end
+            projectmap(split_escape(val)).each do |path|
+              target << basic_option('recurse-submodules', path)
             end
+            target
           else
             target << case val
                       when 'no', '0'
                         '--no-recurse-submodules'
                       when 'yes', 'on-demand'
-                        "--recurse-submodules=#{val}"
+                        "--recurse-submodules#{from == :reset ? '' : "=#{val}"}"
                       else
                         '--recurse-submodules'
                       end
           end
         end
 
-        def git_session(*cmd, worktree: true, **kwargs)
+        def git_session(*cmd, opts: nil, worktree: true, **kwargs)
           dir = worktree ? ["--work-tree=#{shell_quote(path)}", "--git-dir=#{shell_quote(gitpath)}"] : []
-          session('git', *dir, *cmd, **kwargs)
+          ret = session('git', *dir, **kwargs)
+          return ret.merge(cmd) unless opts
+
+          opts = option_sanitize(opts, OPT_GIT[:common]).first
+          [ret.merge(cmd), opts]
         end
 
         def git_output(*cmd, **kwargs)
@@ -1326,9 +1565,7 @@ module Squared
         end
 
         def dryrun?(*, target: @session, **)
-          return false unless target
-
-          target.include?('--dry-run')
+          !!target&.include?('--dry-run')
         end
 
         def quiet?(target: @session)
@@ -1338,11 +1575,11 @@ module Squared
         end
 
         def gitpath
-          basepath('.git')
+          basepath '.git'
         end
 
         def commithash(val)
-          val =~ /\A#\{(\h{5,40})\}\z/ ? $1 : nil
+          val[/^#\{(\h{5,40})\}$/, 1]
         end
 
         def threadargs