RubyGems - squared - Versions diffs - 0.4.7 → 0.4.9 - Mend

squared 0.4.7 → 0.4.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (24) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +106 -1
data/README.ruby.md +57 -28
data/lib/squared/common/base.rb +1 -0
data/lib/squared/common/class.rb +19 -1
data/lib/squared/common/format.rb +35 -38
data/lib/squared/common/prompt.rb +66 -3
data/lib/squared/common/shell.rb +30 -19
data/lib/squared/common/system.rb +3 -3
data/lib/squared/common/utils.rb +11 -10
data/lib/squared/config.rb +4 -5
data/lib/squared/version.rb +1 -1
data/lib/squared/workspace/application.rb +46 -34
data/lib/squared/workspace/project/base.rb +191 -70
data/lib/squared/workspace/project/docker.rb +79 -40
data/lib/squared/workspace/project/git.rb +742 -392
data/lib/squared/workspace/project/node.rb +35 -51
data/lib/squared/workspace/project/python.rb +42 -48
data/lib/squared/workspace/project/ruby.rb +316 -100
data/lib/squared/workspace/project/support/class.rb +37 -19
data/lib/squared/workspace/repo.rb +10 -12
data/lib/squared/workspace/series.rb +11 -7
data/lib/squared/workspace.rb +2 -9
metadata +3 -3

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

@@ -14,20 +14,20 @@ module Squared
         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 { |val| repo << proj if (proj = @project[val.to_s]) && check.(proj) }
+          uri.each { |val| repo << proj if (proj = @project[val.to_s]) && check.call(proj) }
         elsif uri
           data[name.to_s] = uri
         elsif name.is_a?(Enumerable)
           data = name.to_h
         elsif name.is_a?(String) && name.match?(GIT_PROTO)
           base = name
-          @project.each_value { |proj| repo << proj if !proj.parent && check.(proj) }
+          @project.each_value { |proj| repo << proj if !proj.parent && check.call(proj) }
         else
           warn log_message(Logger::WARN, name, subject: 'git', hint: 'invalid', pass: true) if warning
           return self
         end
         if base
-          base = base.match?(GIT_PROTO) ? "#{base.chomp('/')}/" : @root.join(base)
+          base = base.match?(GIT_PROTO) ? "#{base.chomp('/')}/" : @root + base
           repo.each do |target|
             if target.is_a?(Project::Git)
               data[target.localname] = target.project
@@ -46,14 +46,14 @@ module Squared
           end
           unless uri.match?(GIT_PROTO) || Pathname.new(uri).absolute?
             if uri.start_with?('.')
-              uri = @root.join(uri)
+              uri = @root + uri
             elsif base
-              uri = base.is_a?(Pathname) ? base.join(uri) : base + uri
+              uri = base + uri
             else
               next
             end
           end
-          key = task_name(key)
+          key = task_name key
           (GIT_REPO[main] ||= {})[key] = [uri.to_s, opts]
           (@kind[key] ||= []) << Project::Git
         end
@@ -145,115 +145,117 @@ module Squared
     module Project
       class Git < Base
         OPT_GIT = {
-          common: %w[bare paginate 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
+          common: %w[c=q bare glob-pathspecs icase-pathspecs literal-pathspecs no-optional-locks no-pager
+                     no-replace-objects noglob-pathspecs paginate config-env=q exec-path=p namespace=p].freeze,
+          add: %w[A|all e|edit f|force ignore-errors ignore-missing ignore-removal i|interactive no-all
+                  no-ignore-removal n|dry-run p|patch pathspec-file-nul renormalize sparse u|update v|verbose
+                  chmod=b pathspec-from-file=p].freeze,
+          branch: %w[a|all create-reflog i|ignore-case q|quiet r|remotes v|verbose vv abbrev=i color=b column=b
+                     contains=b format=q merged=b no-contains=b no-merged=b points-at=b u|set-upstream-to=b 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
-                       t|track=b].freeze,
-          clean: %w[d x X f|force i|interactive n|dry-run q|quiet e|exlcude=q].freeze,
+                       pathspec-file-nul q|quiet ours theirs conflict=b orphan=b pathspec-from-file=p t|track=b].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
-                     recurse-submodules-default=b].freeze,
-            pull: %w[4 6 n t a|append atomic dry-run f|force k|keep n|negotiate-only prefetch p|prune q|quiet
+            base: %w[multiple progress P|prune-tags refetch stdin u|update-head-ok 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
                      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=q shallow-exclude=e shallow-since=v
+                     recurse-submodules=v refmap=q o|server-option=q shallow-exclude=b shallow-since=v
                      upload-pack=q].freeze
           }.freeze,
+          git: {
+            add: %w[N|intent-to-add refresh].freeze,
+            clean: %w[d x X f|force n|dry-run i|interactive q|quiet e|exclude=q].freeze,
+            mv: %w[k f|force n|dry-run v|verbose].freeze,
+            revert: %w[e S=bm? abort continue n|no-commit quit reference skip cleanup=b gpg-sign=b? m|mainline=i
+                       s|signoff strategy=b X|strategy-option=b].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
+          }.freeze,
           log: {
-            base: %w[all all-match alternate-refs author-date-order basic-regexp bisect boundary cherry cherry-mark
+            base: %w[L=qm all all-match alternate-refs author-date-order basic-regexp bisect boundary cherry cherry-mark
                      cherry-pick clear-decorations date-order dense do-walk exclude-first-parent-only E|extended-regexp
                      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
+                     log-size merge 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=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,
+                     exclude-hidden=b glob=q grep=q grep-reflog=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=q pretty=q?
+                       show-signature date=q diff-merges=b encoding=b expand-tabs=i format=q notes=b 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=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-highligt=q].freeze
+            diff: %w[p R u z B=bm? C=bm? l=im G=qm I=qm M=bm? O=qm S=qm U=im 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 break-rewrites=b? color=b color-moved=b color-moved-ws=b color-words=q?
+                     diff-algorithm=b diff-filter=e? X|dirstat=b? dirstat-by-file=b? dst-prefix=q find-copies=i?
+                     find-object=b find-renames=b? 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=b? stat-count=i stat-width=i stat-name-width=i
+                     submodule=b? unified=i word-diff=b? word-diff-regex=q ws-error-highlight=b].freeze
           }.freeze,
-          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
+          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
                        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=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=v? s|strategy=b
+          ls_remote: %w[exit-code get-url q|quiet symref o|server-option=q sort=q upload-pack=q].freeze,
+          merge: %w[e n S=bm? allow-unrelated-histories ff-only m=q q|quiet v|verbose cleanup=b F|file=p gpg-sign=b?
+                    into-name=b log=i s|strategy=b X|strategy-option=b].freeze,
+          pull: %w[e n S=bm? allow-unrelated-histories ff-only cleanup=b gpg-sign=b? log=i r|rebase=v? 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=qq onto=e
-                     s|strategy=b X|strategy-option=b whitespace=b].freeze,
+          rebase: %w[n C=im S=bm? allow-empty-message apply committer-date-is-author-date edit-todo empty=b
+                     f|force-rebase ignore-date ignore-whitespace i|interactive keep-base m|merge no-ff q|quiet quit
+                     reset-author-date root show-current-patch signoff v|verbose empty=b x|exec=q gpg-sign=b? onto=b
+                     r|rebase-merges=b 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 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,
+          restore: %w[ignore-skip-worktree-bits ignore-unmerged m|merge ours p|patch pathspec-file-nul q|quiet S|staged
+                      theirs W|worktree conflict=b pathspec-from-file=p s|source=b].freeze,
+          rev_parse: %w[absolute-git-dir all git-common-dir git-dir is-bare-repository is-inside-git-dir
+                        is-inside-work-tree is-shallow-repository local-env-vars no-revs not q|quiet revs-only
+                        shared-index-path show-cdup show-prefix show-superproject-working-tree show-toplevel sq sq-quote
+                        symbolic symbolic-full-name verify abbrev-ref=b? after=q before=q branches=q? default=q
+                        disambiguate=b exclude=q exclude-hidden=b git-path=p glob=q path-format=b? prefix=q remotes=q?
+                        resolve-git-dir=p short=i? show-object-format=b? since=q tags=q? until=q].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: {
             common: %w[q|quiet].freeze,
-            push: %w[a|all u|include-untracked k|keep-index no-keep-index p|patch S|staged m|message=q
-                     pathspec-from-file=p].freeze,
+            push: %w[a|all u|include-untracked k|keep-index no-keep-index no-include-untracked pathspec-file-nul
+                     p|patch S|staged m|message=q pathspec-from-file=p].freeze,
             pop: %w[index].freeze,
             apply: %w[index].freeze
           }.freeze,
-          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,
+          status: %w[u|ignore-submodules=bm? ignored=b? untracked-files=b?],
+          tag: %w[n=im cleanup=b create-reflog i|ignore-case color=b? column=b contains=b? format=q merged=b?
+                  no-contains=b? no-merged=b? points-at=q sort=q].freeze,
           no: {
+            branch: %w[color color-moved column track].freeze,
+            checkout: %w[overwrite-ignore guess overlay progress recurse-submodules track].freeze,
             fetch: {
               base: %w[auto-gc auto-maintenance write-commit-graph write-fetch-head].freeze,
               pull: %w[all ipv4 ipv6 recurse-submodules show-forced-updates tags].freeze
             },
             log: {
               base: %w[decorate mailmap merges use-mailmap].freeze,
-              show: %w[abbrev-commit expand-tabs notes].freeze,
-              diff: %w[color color-moved ext-diff indent-heuristic patch relative rename-empty textconv].freeze
+              diff: %w[color color-moved ext-diff indent-heuristic patch relative rename-empty textconv].freeze,
+              show: %w[abbrev-commit expand-tabs notes].freeze
             }.freeze,
-            pull: %w[autostash commit edit ff log signoff squash stat verify verify-signatures gpg-sign rebase].freeze,
-            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
+            merge: %w[autostash edit ff gpg-sign log overwrite-ignore progress 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,
+            pull: %w[autostash commit edit gpg-sign ff log rebase signoff squash stat verify verify-signatures].freeze,
+            rebase: %w[autosquash autostash fork-point gpg-sign keep-empty reapply-cherry-picks rebase-merges
+                       rerere-autoupdate reschedule-failed-exec stat update-refs verify].freeze,
             reset: %w[refresh].freeze,
             restore: %w[overlay progress recurse-submodules].freeze,
+            rev_parse: %w[flags].freeze,
             revert: %w[edit gpg-sign rerere-autoupdate].freeze,
-            show: %w[standard-notes].freeze
+            show: %w[standard-notes].freeze,
+            tag: %w[column].freeze
           }.freeze
         }.freeze
         VAL_GIT = {
@@ -272,7 +274,7 @@ module Squared
           include Rake::DSL
           def populate(ws, **)
-            return if ws.series[:pull].empty?
+            return if ws.series.exclude?(:pull, true)
             namespace(name = ws.task_name('git')) do
               all = ws.task_join(name, 'all')
@@ -297,7 +299,7 @@ module Squared
           end
           def tasks
-            %i[pull rebase fetch clone stash status branch revbuild].freeze
+            %i[pull rebase autostash fetch clone stash status branch revbuild].freeze
           end
           def config?(val)
@@ -308,23 +310,24 @@ module Squared
         end
         subtasks({
-          'branch' => %i[create set delete move copy list edit current].freeze,
+          'branch' => %i[create track delete move copy list current].freeze,
           'checkout' => %i[commit branch track detach path].freeze,
-          'commit' => %i[add all amend amend-orig].freeze,
+          'commit' => %i[add all amend amend-orig fixup].freeze,
           'diff' => %i[head branch files view between contain].freeze,
           'fetch' => %i[origin remote].freeze,
-          'files' => %i[cached modified deleted others ignored].freeze,
-          'git' => %i[clean mv revert rm].freeze,
+          'files' => %i[cached modified deleted others].freeze,
+          'git' => %i[add clean mv 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[staged worktree].freeze,
-          'rev' => %i[commit branch output parseopt build].freeze,
+          'restore' => %i[source staged worktree].freeze,
+          'rev' => %i[commit build output].freeze,
           'show' => %i[format oneline textconv].freeze,
           'stash' => %i[push pop apply drop clear list].freeze,
+          'switch' => %i[create detach merge].freeze,
           'tag' => %i[add sign delete list].freeze
         })
@@ -342,7 +345,7 @@ module Squared
           return unless ref?(Git.ref)
           namespace name do
-            @@tasks[Git.ref].each do |action, flags|
+            Git.subtasks do |action, flags|
               next if @pass.include?(action)
               namespace action do
@@ -350,7 +353,7 @@ module Squared
                   case action
                   when 'pull', 'fetch'
                     if flag == :remote
-                      format_desc(action, flag, 'remote,opts*')
+                      format_desc action, flag, 'remote,opts*'
                       task flag, [:remote] do |_, args|
                         remote = param_guard(action, flag, args: args, key: :remote)
                         __send__(action, flag, args.extras, remote: remote)
@@ -366,13 +369,39 @@ module Squared
                     when :all
                       format_desc action, flag, 'message?'
                       task flag, [:message] do |_, args|
-                        commit(flag, message: args.fetch(:message, nil))
+                        commit(flag, message: args.message)
                       end
                     else
-                      format_desc action, flag, 'pathspec+'
+                      format_desc(action, flag, 'pathspec+', before: flag == :add ? 'opts*' : nil)
                       task flag do |_, args|
-                        refs = param_guard(action, flag, args: args.to_a)
-                        commit(flag, refs: refs)
+                        if flag == :fixup
+                          ref, squash, pick = choice_commit(accept: [['Auto squash?', true]], reflog: false,
+                                                            values: ['Pick [amend|reword]'])
+                          pick = case pick&.downcase
+                                 when 'a', 'amend'
+                                   'amend'
+                                 when 'r', 'reword'
+                                   'reword'
+                                 end
+                          if squash
+                            found = false
+                            git_spawn(git_output('log --format=%h'), stdout: false).each do |val|
+                              if found
+                                squash = val.chomp
+                                break
+                              end
+                              found = val.chomp == ref
+                            end
+                          end
+                        end
+                        refs = pick == 'reword' ? [] : param_guard(action, flag, args: args.to_a)
+                        if flag == :add
+                          opts = refs
+                          refs = []
+                        else
+                          opts = []
+                        end
+                        commit(flag, opts, refs: refs, ref: ref, squash: squash, pick: pick)
                       end
                     end
                   when 'tag'
@@ -385,61 +414,103 @@ module Squared
                     when :delete
                       format_desc action, flag, 'name+'
                       task flag do |_, args|
-                        refs = param_guard(action, flag, args: args.to_a)
-                        tag(flag, refs: refs)
+                        refs = args.to_a
+                        if refs.empty?
+                          refs = choice_refs('Choose a tag', 'tags', multiple: true, accept: 'Delete?', series: true)
+                          remote = choice_remote
+                        end
+                        tag(flag, refs: refs, remote: remote)
                       end
                     when :add, :sign
-                      format_desc action, flag, 'name,message?,commit?'
-                      task flag, [:name, :message, :commit] do |_, args|
-                        name = param_guard(action, flag, args: args, key: :name)
-                        tag(flag, refs: [name], message: args.message, commit: args.commit)
+                      format_desc action, flag, 'name,message?,commit?,remote?'
+                      task flag, [:name, :message, :commit, :remote] do |_, args|
+                        if (name = args.name)
+                          message = args.message
+                          commit = commithead args.commit
+                          remote = args.remote
+                        else
+                          commit, name, message = choice_commit(values: [['Enter tag name', true], 'Enter message'],
+                                                                series: true, reflog: false)
+                          remote = choice_remote
+                        end
+                        ret = tag(flag, refs: [name], message: message, commit: commit, remote: remote)
+                        print_success if success?(ret) && !remote
                       end
                     end
                   when 'stash'
-                    if flag == :list
-                      format_desc action, flag
-                    else
-                      format_desc(action, flag, '*opts', after: flag == :push ? 'pathspec*' : 'commit?')
-                    end
+                    format_desc(action, flag, 'opts*', after: case flag
+                                                              when :push then 'pathspec*'
+                                                              when :list then nil
+                                                              else 'commit?' end)
                     task flag do |_, args|
                       stash flag, args.to_a
                     end
                   when 'log', 'diff'
                     case flag
                     when :view, :between, :contain
-                      if flag == :view && action == 'log'
-                        format_desc action, flag, '(^)commit/H0*,pathspec*,opts*'
+                      view = flag == :view
+                      if view && action == 'log'
+                        format_desc action, flag, '(^)commit*|:,opts*,ref?,pathspec*'
                         task flag do |_, args|
-                          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)
+                          args = args.to_a
+                          if args.first == ':'
+                            args.shift
+                            index = choice_commit(multiple: true)
+                          else
+                            index = []
+                            args.each do |val|
+                              if matchhead(val)
+                                index << commithead(val)
+                              elsif (sha = commithash(val))
+                                index << sha
+                              elsif val.start_with?('^')
+                                index << shell_quote(val)
+                              else
+                                break
+                              end
                             end
+                            args = args.drop(index.size)
                           end
-                          logx(flag, args.to_a.drop(index.size), index: index)
+                          log!(flag, args, index: index)
                         end
                       else
-                        format_desc action, flag, 'commit1,commit2,pathspec*,opts*'
+                        format_desc action, flag, 'commit1,commit2,opts*,pathspec*'
                         task flag, [:commit1, :commit2] do |_, args|
-                          commit1 = param_guard(action, flag, args: args, key: :commit1)
-                          commit2 = param_guard(action, flag, args: args, key: :commit2)
-                          __send__(action == 'log' ? :logx : :diff, flag, args.extras, range: [commit1, commit2])
+                          commit1 = commithead args.commit1
+                          if commit1
+                            commit2 = commithead param_guard(action, flag, args: args, key: :commit2)
+                            args = args.extras.to_a
+                            range = [commit1, commit2]
+                          else
+                            range, opts, refs = choice_commit(multiple: view ? true : 2, values: %w[Options Pathspec])
+                            range = range.reverse
+                            args = OptionPartition.strip(opts)
+                            args.concat(refs.shellsplit) if refs
+                          end
+                          __send__(action == 'log' ? :log! : :diff, flag, args, range: range)
                         end
                       end
                     when :head
-                      format_desc action, flag, 'commit/H0*,opts*,pathspec*'
+                      format_desc action, flag, 'commit*|:,opts*,pathspec*'
                       task flag do |_, args|
-                        index = []
-                        args.to_a.each do |val|
-                          break unless val =~ /^H(\d+)$/ || (sha = commithash(val))
-                          index << ($1 ? "HEAD~#{$1}" : sha)
+                        args = args.to_a
+                        if args.first == ':'
+                          args.shift
+                          index = choice_commit(multiple: true)
+                        else
+                          index = []
+                          args.each do |val|
+                            if matchhead(val)
+                              index << commithead(val)
+                            elsif (sha = commithash(val))
+                              index << sha
+                            else
+                              break
+                            end
+                          end
+                          args = args.drop(index.size)
                         end
-                        diff(flag, args.to_a.drop(index.size), index: index)
+                        diff(flag, args, index: index)
                       end
                     when :branch
                       format_desc action, flag, 'name,opts*,pathspec*'
@@ -460,42 +531,61 @@ module Squared
                     when :branch
                       format_desc action, flag, 'name,create?=[bB],commit?,detach?=d'
                       task flag, [:name, :create, :commit, :detach] do |_, args|
-                        branch = param_guard(action, flag, args: args, key: :name)
-                        create = args.create
-                        if args.commit == 'd'
-                          detach = 'd'
-                          commit = nil
-                        elsif create == 'd'
-                          create = nil
-                          commit = nil
-                          detach = 'd'
-                        elsif create && create.size > 1
-                          commit = create
-                          create = nil
-                          detach = args.commit
+                        if (branch = args.name)
+                          branch = param_guard(action, flag, args: args, key: :name)
+                          create = args.create
+                          if args.commit == 'd'
+                            detach = 'd'
+                            commit = nil
+                          elsif create == 'd'
+                            create = nil
+                            commit = nil
+                            detach = 'd'
+                          elsif create && create.size > 1
+                            commit = commithead create
+                            create = nil
+                            detach = args.commit
+                          else
+                            detach = args.detach
+                            commit = commithead args.commit
+                          end
+                          param_guard(action, flag, args: { create: create }, key: :create, pat: /\Ab\z/i) if create
                         else
-                          detach = args.detach
-                          commit = args.commit
+                          branch = choice_refs 'Choose a branch to switch'
                         end
-                        param_guard(action, flag, args: { create: create }, key: :create, pat: /\Ab\z/i) if create
                         checkout(flag, branch: branch, create: create, commit: commit, detach: detach)
                       end
                     when :track
                       format_desc action, flag, 'origin,(^)name?'
                       task flag, [:origin, :name] do |_, args|
-                        origin = param_guard(action, flag, args: args, key: :origin)
-                        checkout(flag, branch: args.name, origin: origin)
+                        if (origin = args.origin)
+                          branch = args.name
+                        else
+                          origin, branch = choice_refs('Choose a remote', 'remotes', values: ['Enter branch name'])
+                        end
+                        checkout(flag, branch: branch, origin: origin)
                       end
                     when :commit
-                      format_desc action, flag, 'branch/commit,opts*'
+                      format_desc action, flag, 'ref,opts*'
                       task flag, [:commit] do |_, args|
-                        commit = param_guard(action, flag, args: args, key: :commit)
-                        checkout(flag, commit: commit)
+                        commit = commithead args.commit
+                        if commit
+                          args = args.extras
+                        else
+                          commit, opts = choice_commit(values: ['Options'])
+                          args = OptionPartition.strip(opts)
+                        end
+                        checkout(flag, args, commit: commit)
                       end
                     when :detach
-                      format_desc action, flag, 'branch/commit?'
+                      format_desc action, flag, 'ref?'
                       task flag, [:commit] do |_, args|
-                        checkout(flag, commit: args.commit)
+                        commit = commithead args.commit
+                        unless commit
+                          commit, merge = choice_commit(values: ['Merge? [y|N]'])
+                          merge = merge&.upcase == 'Y'
+                        end
+                        checkout(flag, commit: commit, merge: merge)
                       end
                     when :path
                       format_desc action, flag, 'opts*,pathspec*'
@@ -506,27 +596,46 @@ module Squared
                   when 'branch'
                     case flag
                     when :create
-                      format_desc action, flag, 'name,ref?=HEAD'
+                      format_desc action, flag, 'name,ref?=HEAD|:'
                       task flag, [:name, :ref] do |_, args|
                         target = param_guard(action, flag, args: args, key: :name)
-                        branch(flag, target: target, ref: args.ref)
+                        ref = commithead args.ref
+                        ref, remote = choice_refs('Choose a remote', 'remotes', accept: [['Push?', true]]) if ref == ':'
+                        branch(flag, target: target, ref: ref, remote: remote)
                       end
-                    when :set
-                      format_desc(action, flag, '(^)upstream,name?')
+                    when :track
+                      format_desc action, flag, '(^~)upstream?,name?'
                       task flag, [:upstream, :name] do |_, args|
-                        upstream = param_guard(action, flag, args: args, key: :upstream)
-                        branch(flag, target: args.name, ref: upstream)
+                        if (ref = args.upstream)
+                          target = args.name
+                          if ref.start_with?('~')
+                            ref = ref[1..-1]
+                            remote = true
+                          end
+                        else
+                          ref, remote, target = choice_refs('Choose a remote', 'remotes', accept: [['Push?', true]],
+                                                                                          values: ['Enter branch name'])
+                        end
+                        branch(flag, target: target, ref: ref, remote: remote)
                       end
                     when :delete
-                      format_desc action, flag, '(^~)name+'
+                      format_desc action, flag, '(^~)name*,:?'
                       task flag do |_, args|
-                        refs = param_guard(action, flag, args: args.to_a)
-                        branch(flag, refs: refs)
-                      end
-                    when :edit
-                      format_desc action, flag, 'name?'
-                      task flag, [:name] do |_, args|
-                        branch(flag, target: args.name)
+                        refs = args.to_a
+                        if refs.empty? || (r = refs.last == ':')
+                          accept = ['Delete?']
+                          accept << ['Force?', true] unless r
+                          remote = choice_refs('Choose a branch', r ? 'remotes' : 'heads', multiple: true,
+                                                                                           accept: accept)
+                          if r
+                            refs.pop
+                          else
+                            refs = remote.first
+                            refs.map! { |val| "^#{val}" } if remote[1]
+                            remote = nil
+                          end
+                        end
+                        branch(flag, refs: refs, remote: remote)
                       end
                     when :list
                       format_desc action, flag, 'opts*,pattern*'
@@ -541,17 +650,55 @@ module Squared
                     else
                       format_desc action, flag, 'branch,oldbranch?'
                       task flag, [:branch, :oldbranch] do |_, args|
-                        branch = param_guard(action, flag, args: args, key: :branch)
-                        branch(flag, refs: [args.oldbranch, branch])
+                        if (branch = args.branch)
+                          oldbranch = args.oldbranch
+                        else
+                          oldbranch, branch = choice_refs("Choose a branch to #{flag}",
+                                                          values: [['Enter new branch name', true]])
+                        end
+                        branch(flag, refs: [oldbranch, branch])
+                      end
+                    end
+                  when 'switch'
+                    case flag
+                    when :create
+                      format_desc action, flag, '(^)name,ref?=HEAD|:'
+                      task flag, [:name, :commit] do |_, args|
+                        target = param_guard(action, flag, args: args, key: :name)
+                        commit = commithead args.commit
+                        commit, track = choice_commit(values: ['Track? [Y|n]'], force: false) if commit == ':'
+                        switch(flag, target: target, commit: commit, track: track)
+                      end
+                    when :detach
+                      format_desc action, flag, 'ref?=HEAD'
+                      task flag, [:commit] do |_, args|
+                        commit = commithead(args.commit) || choice_commit(force: false)
+                        switch(flag, commit: commit)
+                      end
+                    when :merge
+                      format_desc action, flag, 'branch?'
+                      task flag, [:branch] do |_, args|
+                        commit = args.branch || choice_refs('Choose a branch')
+                        switch(flag, commit: commit)
                       end
                     end
                   when 'reset'
                     case flag
                     when :commit
-                      format_desc action, flag, 'branch/commit,opts*'
+                      format_desc action, flag, 'ref|:,opts*'
                       task flag, [:commit] do |_, args|
-                        commit = param_guard(action, flag, args: args, key: :commit)
-                        reset(flag, args.extras, commit: commit)
+                        commit = commithead args.commit
+                        if commit && commit != ':'
+                          args = args.extras
+                        else
+                          commit, mode = choice_commit(values: ['Mode [mixed|soft|hard|N]'])
+                          args = args.extras.to_a.concat(case mode&.downcase
+                                                         when 'h', 'hard' then ['hard']
+                                                         when 's', 'soft' then ['soft']
+                                                         when 'n', 'N' then ['mixed', 'N']
+                                                         else ['mixed'] end)
+                        end
+                        print_success if success?(reset(flag, args, commit: commit))
                       end
                     when :index
                       format_desc action, flag, 'opts*,pathspec*'
@@ -559,15 +706,18 @@ module Squared
                         reset flag, args.to_a
                       end
                     when :mode
-                      format_desc action, flag, 'mode,ref?=HEAD'
+                      format_desc action, flag, 'mode,ref?=HEAD|:'
                       task flag, [:mode, :ref] do |_, args|
                         mode = param_guard(action, flag, args: args, key: :mode)
-                        reset(flag, mode: mode, ref: args.ref)
+                        ref = commithead args.ref
+                        ref = choice_commit(reflog: false) if ref == ':'
+                        reset(flag, mode: mode, ref: ref)
                       end
                     when :patch
-                      format_desc action, flag, 'ref,pathspec*'
+                      format_desc action, flag, 'ref?=HEAD|:,pathspec*'
                       task flag, [:ref] do |_, args|
-                        ref = param_guard(action, flag, args: args, key: :ref)
+                        ref = commithead args.ref
+                        ref = choice_commit(reflog: false) unless ref && ref != ':'
                         reset(flag, refs: args.extras, ref: ref)
                       end
                     end
@@ -576,7 +726,7 @@ module Squared
                     when :oneline
                       format_desc action, flag, 'opts*,object*'
                       task flag do |_, args|
-                        show flag, args.to_a.push('abbrev-commit')
+                        show flag, args.to_a
                       end
                     when :format
                       format_desc action, flag, 'format?,opts*,object*'
@@ -593,23 +743,42 @@ module Squared
                   when 'rebase', 'merge'
                     case flag
                     when :branch
-                      format_desc action, flag, 'opts*,upstream?,branch?'
-                      task flag do |_, args|
-                        args = param_guard(action, flag, args: args.to_a)
-                        rebase flag, args
+                      format_desc action, flag, 'upstream,branch?=HEAD,opts*'
+                      task flag, [:upstream] do |_, args|
+                        if (upstream = args.upstream)
+                          args = args.extras
+                        else
+                          upstream, opts = choice_refs('Choose upstream branch', values: ['Options'])
+                          args = OptionPartition.strip(opts)
+                        end
+                        rebase(flag, args, upstream: upstream)
                       end
                     when :onto
-                      format_desc action, flag, 'branch/commit,upstream,branch?=HEAD'
+                      format_desc action, flag, 'ref,upstream,branch?=HEAD'
                       task flag, [:commit, :upstream, :branch] do |_, args|
-                        commit = param_guard(action, flag, args: args, key: :commit)
-                        upstream = param_guard(action, flag, args: args, key: :upstream)
-                        rebase(flag, commit: commit, upstream: upstream, branch: args.branch)
+                        commit = commithead args.commit
+                        if commit
+                          upstream = param_guard(action, flag, args: args, key: :upstream)
+                          branch = args.branch
+                          args = []
+                        else
+                          commit = choice_refs 'Choose "onto" branch'
+                          target, opts = choice_commit(multiple: 2, values: ['Options'], reflog: false)
+                          branch, upstream = target
+                          args = OptionPartition.strip(opts)
+                        end
+                        rebase(flag, args, commit: commit, upstream: upstream, branch: branch)
                       end
                     when :commit, :'no-commit'
-                      format_desc action, flag, 'branch/commit+,opts*'
+                      format_desc action, flag, 'refs+,opts*'
                       task flag do |_, args|
-                        args = param_guard(action, flag, args: args.to_a)
-                        merge flag, args
+                        args = args.to_a
+                        if args.empty?
+                          accept = "Merge with #{`#{git_output('branch --show-current')}`.chomp}?"
+                          branch, opts = choice_refs('Choose a branch', values: ['Options'], accept: accept)
+                          args = OptionPartition.strip(opts)
+                        end
+                        merge(flag, args, branch: branch)
                       end
                     when :send
                       format_desc(action, flag, VAL_GIT[action.to_sym][:send], arg: nil)
@@ -624,25 +793,20 @@ module Squared
                     when :commit
                       format_desc action, flag, 'ref?=HEAD,size?'
                       task flag, [:ref, :size] do |_, args|
-                        ref = args.ref
+                        ref = commithead args.ref
                         size = args.size
-                        if !size && ref.to_i > 0
+                        if !size && ref.to_i.between?(1, 40)
                           size = ref
                           ref = nil
                         end
                         rev_parse(flag, ref: ref, size: size)
                       end
-                    when :branch
-                      format_desc action, flag, 'ref?=HEAD'
-                      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
+                    when :output
                       format_desc action, flag, 'opts*,args*'
                       task flag do |_, args|
                         rev_parse flag, args.to_a
@@ -650,10 +814,9 @@ module Squared
                     end
                   when 'refs', 'files'
                     if flag == :remote
-                      format_desc action, flag, 'remote,opts*,pattern*'
+                      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.extras, remote: args.remote)
                       end
                     else
                       format_desc action, flag, 'opts*,pattern*'
@@ -661,17 +824,57 @@ module Squared
                         __send__(action == 'refs' ? :ls_remote : :ls_files, flag, args.to_a)
                       end
                     end
-                  when 'restore', 'git'
-                    format_desc(action, flag, 'opts*', before: case flag
-                                                               when :rm
-                                                                 'source+,destination'
-                                                               when :revert
-                                                                 'commit+'
-                                                               else
-                                                                 'pathspec*'
-                                                               end)
+                  when 'restore'
+                    case flag
+                    when :source
+                      format_desc action, flag, 'ref,opts*,pathspec*'
+                      task flag, [:commit] do |_, args|
+                        commit = commithead args.commit
+                        if commit
+                          args = args.extras
+                        else
+                          commit, opts, files = choice_commit(values: ['Options', ['Pathspec', true]])
+                          args = OptionPartition.strip(opts)
+                          files = files&.shellsplit
+                        end
+                        restore(flag, args, commit: commit, files: files)
+                      end
+                    when :staged, :worktree
+                      format_desc action, flag, 'opts*,pathspec*,:?'
+                      task flag do |_, args|
+                        args = args.to_a
+                        if args.empty? || args.last == ':'
+                          files = []
+                          git_spawn('status -s --porcelain', stdout: false).each do |line|
+                            next unless line =~ /^(.)(.)\s+(.+)$/
+                            case (flag == :staged ? $1 : $2)
+                            when 'A', 'M'
+                              files << $3
+                            end
+                          end
+                          unless files.empty?
+                            files = choice_index('Select a file', files, multiple: true, force: false,
+                                                                         accept: 'Restore?')
+                          end
+                          args.pop
+                          args, glob = args.partition { |val| val.match?(/^(?:[a-z-]+=|[^*]+$)/) }
+                          (files ||= []).concat(glob)
+                          next if args.empty? && files.empty?
+                        end
+                        restore(flag, args, files: files)
+                      end
+                    end
+                  when 'git'
+                    before = case flag
+                             when :rm then 'source+,destination'
+                             when :revert then 'commit+' end
+                    format_desc(action, flag, 'opts*', before: before, after: case flag
+                                                                              when :add, :clean, :mv
+                                                                                'pathspec*'
+                                                                              end)
                     task flag do |_, args|
-                      __send__(action, flag, args.to_a)
+                      git flag, args.to_a
                     end
                   end
                 end
@@ -699,15 +902,18 @@ module Squared
           cmd, opts = git_session('pull', opts: opts)
           if flag == :rebase
             cmd << '--rebase'
-          elsif (val = option('rebase', ignore: false))
-            cmd << case val
-                   when '0', 'false'
-                     '--no-rebase'
-                   else
-                     VAL_GIT[:rebase][:value].include?(val) ? basic_option('rebase', val) : '--rebase'
-                   end
+            cmd << '--autostash' if option('autostash')
+          else
+            cmd << '--autostash' if flag == :autostash
+            if (val = option('rebase', ignore: false))
+              cmd << case val
+                     when '0', 'false'
+                       '--no-rebase'
+                     else
+                       VAL_GIT[:rebase][:value].include?(val) ? basic_option('rebase', val) : '--rebase'
+                     end
+            end
           end
-          cmd << '--autostash' if option('autostash')
           append_pull(opts, OPT_GIT[:pull] + OPT_GIT[:fetch][:pull],
                       no: OPT_GIT[:no][:pull] + OPT_GIT[:no][:fetch][:pull], remote: remote, flag: flag)
           source(sync: sync, sub: if verbose
@@ -725,16 +931,12 @@ module Squared
           cmd, opts = git_session('rebase', opts: opts)
           case flag
           when :branch
+            return unless upstream
             op = OptionPartition.new(opts, OPT_GIT[:rebase], cmd, project: self, no: OPT_GIT[:no][:rebase])
-            case op.size
-            when 0
-              append_head
-            when 1, 2
-              op.append(delim: true)
-            else
-              op.append(op.pop(2), delim: true)
-                .clear(pass: false)
-            end
+            cmd << shell_escape(upstream)
+            append_head op.shift
+            op.clear(pass: false)
           when :onto
             return unless upstream
@@ -750,6 +952,10 @@ module Squared
           source
         end
+        def autostash(*, sync: invoked_sync?('autostash'), **)
+          pull(:autostash, sync: sync)
+        end
         def fetch(flag = nil, opts = [], sync: invoked_sync?('fetch', flag), remote: nil)
           cmd, opts = git_session('fetch', opts: opts)
           append_pull(opts, collect_hash(OPT_GIT[:fetch]), no: collect_hash(OPT_GIT[:no][:fetch]), remote: remote,
@@ -784,8 +990,12 @@ module Squared
         def stash(flag = nil, opts = [], sync: invoked_sync?('stash', flag))
           if flag
             cmd, opts = git_session('stash', flag, opts: opts)
-            op = OptionPartition.new(opts, OPT_GIT[:stash][:common] + OPT_GIT[:stash].fetch(flag, []), cmd,
-                                     project: self)
+            list = OPT_GIT[:stash][:common] + OPT_GIT[:stash].fetch(flag, [])
+            if flag == :list
+              list += collect_hash(OPT_GIT[:log])
+              no = collect_hash(OPT_GIT[:no][:log])
+            end
+            op = OptionPartition.new(opts, list, cmd, project: self, no: no, first: flag == :push ? matchpathspec : nil)
             case flag
             when :push
               append_pathspec op.extras
@@ -800,6 +1010,7 @@ module Squared
               end
               return
             when :list
+              op.clear
               out, banner, from = source(io: true)
               print_item banner
               list_result(write_lines(out), 'objects', from: from)
@@ -807,8 +1018,8 @@ module Squared
             end
           else
             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)
+            append_option(OPT_GIT[:stash][:push].grep_v(/[=|]/), no: true, ignore: false)
+            append_message
           end
           source(banner: !quiet?, sync: sync, **threadargs)
         end
@@ -816,6 +1027,7 @@ module Squared
         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'
@@ -829,18 +1041,22 @@ module Squared
                                                      end)
           end
           append_pathspec
+          if verbose
+            r = color(:red)
+            g = color(:green)
+            sub = if session_arg?('short')
+                    [
+                      { pat: /^(.)([A-Z?!])(.+)$/, styles: r, index: 2 },
+                      { pat: /^([A-Z?!])(.+)$/, styles: g },
+                      { pat: /^(\?\?)(.+)$/, styles: r },
+                      { pat: /^(## )(.+?)(\.{3})(.+)$/, styles: [nil, g, nil, r], index: -1 }
+                    ]
+                  else
+                    [{ pat: /^(\t+)([a-z]+: +.+)$/, styles: r, index: 2 }]
+                  end
+          end
           out, banner, from = source(io: true)
-          ret = write_lines(out, banner: banner, sub: if verbose
-                                                        r = color(:red)
-                                                        g = color(:green)
-                                                        [
-                                                          { pat: /^(.)([A-Z?!])(.+)$/, styles: r, index: 2 },
-                                                          { pat: /^([A-Z?!])(.+)$/, styles: g },
-                                                          { pat: /^(\?\?)(.+)$/, styles: r },
-                                                          { pat: /^(## )(.+)(\.{3})(.+)$/,
-                                                            styles: [nil, g, nil, r], index: -1 }
-                                                        ]
-                                                      end)
+          ret = write_lines(out, banner: banner, sub: sub)
           list_result(ret, 'files', from: from, action: 'modified')
         end
@@ -853,16 +1069,16 @@ module Squared
           end
           unless workspace.closed
             if @revbuild
-              statusargs.().each { |key, val| @revbuild[key] += val }
+              statusargs.call.each { |key, val| @revbuild[key] += val }
             else
-              @revbuild = statusargs.()
+              @revbuild = statusargs.call
             end
             return
           end
-          sha = git_spawn('rev-parse --verify HEAD').first.to_s.chomp
+          sha = git_spawn('rev-parse --verify HEAD').chomp
           return if sha.empty?
-          kwargs = kwargs.key?(:include) || kwargs.key?(:exclude) ? statusargs.() : @revbuild || {}
+          kwargs = kwargs.key?(:include) || kwargs.key?(:exclude) ? statusargs.call : @revbuild || {}
           case flag
           when :build
             op = OptionPartition.new(opts, OPT_GIT[:status], project: self)
@@ -904,13 +1120,14 @@ module Squared
           case flag
           when :commit, :index
             op = OptionPartition.new(opts, OPT_GIT[:reset] + VAL_GIT[:reset], cmd,
-                                     project: self, no: OPT_GIT[:no][:reset])
+                                     project: self, no: OPT_GIT[:no][:reset],
+                                     first: flag == :index ? matchpathspec : nil)
             if flag == :commit
-              op.append(commit, delim: true)
+              op.append(commit)
                 .clear(pass: false)
               ref = false
             else
-              (refs ||= []).concat(op.extras)
+              refs = op.extras
             end
           when :mode
             return unless VAL_GIT[:reset].include?(mode)
@@ -922,6 +1139,7 @@ module Squared
             end
           when :patch
             cmd << '--patch'
+            append_pathspec(refs, pass: false)
           end
           unless ref == false
             append_commit(ref, head: true)
@@ -930,39 +1148,41 @@ module Squared
           source
         end
-        def checkout(flag, opts = [], branch: nil, origin: nil, create: nil, commit: nil, detach: nil)
+        def checkout(flag, opts = [], branch: nil, origin: nil, create: nil, commit: nil, detach: nil, merge: false)
           cmd, opts = git_session('checkout', opts: opts)
           append_option 'force', 'merge'
           case flag
           when :branch
             cmd << '--detach' if detach == 'd' || option('detach')
             append_option('track', equals: true)
-            cmd << (create ? shell_option(create, branch) : branch) << commit
+            cmd << (create ? quote_option(create, branch) : branch) << commit
           when :track
             if branch
               if branch.start_with?('^')
                 opt = 'B'
                 branch = branch[1..-1]
               end
-              cmd << shell_option(opt || 'b', branch)
+              cmd << quote_option(opt || 'b', branch)
             end
-            cmd << '--track' << origin
+            cmd << '--track' << shell_quote(origin)
           when :detach
+            cmd << '-m' if merge
             cmd << '--detach' << commit
           else
-            op = OptionPartition.new(opts, OPT_GIT[:checkout], cmd, project: self, no: OPT_GIT[:no][:checkout])
+            op = OptionPartition.new(opts, OPT_GIT[:checkout], cmd, project: self, no: OPT_GIT[:no][:checkout],
+                                                                    first: flag == :path ? matchpathspec : nil)
             if flag == :commit
-              op.append(commit, delim: true)
+              op.append(commit)
                 .clear(pass: false)
             else
               append_head
-              append_pathspec op.extras
+              append_pathspec(op.extras, pass: false)
             end
           end
           source
         end
-        def tag(flag, opts = [], refs: [], message: nil, commit: nil)
+        def tag(flag, opts = [], refs: [], message: nil, commit: nil, remote: nil)
           cmd, opts = git_session('tag', opts: opts)
           case flag
           when :add, :sign
@@ -974,31 +1194,32 @@ module Squared
             cmd << '--force' if option('force')
             if !commit && message && (sha = commithash(message))
               commit = sha
-            else
-              append_message message
+              message = nil
             end
+            append_message message
             append_value refs
             append_head commit
-          when :list
+          when :delete
+            cmd << '--delete'
+            append_value refs
+          else
             op = OptionPartition.new(opts, OPT_GIT[:tag], cmd << '--list', project: self, no: OPT_GIT[:no][:tag])
             out, banner, from = source(io: true)
             print_item banner
             ret = write_lines(out, grep: op.extras)
             list_result(ret, 'tags', from: from, grep: op.extras)
             return
-          when :delete
-            cmd << '--delete'
-            append_value refs
-          else
-            cmd << shell_option(flag, commit)
           end
+          remote ||= option('remote')
           source
+          git_spawn('push', flag == :delete ? '-d' : nil, remote, *refs.map { |val| shell_quote(val) }) if remote
         end
-        def logx(flag, opts = [], range: [], index: [])
+        def log!(flag, opts = [], range: [], index: [])
           cmd, opts = git_session('log', opts: opts)
           op = OptionPartition.new(opts, collect_hash(OPT_GIT[:log]), cmd,
-                                   project: self, no: collect_hash(OPT_GIT[:no][:log]))
+                                   project: self, no: collect_hash(OPT_GIT[:no][:log]),
+                                   first: matchpathspec)
           case flag
           when :between, :contain
             op << shell_quote(range.join(flag == :between ? '..' : '...'))
@@ -1013,7 +1234,8 @@ module Squared
         def diff(flag, opts = [], refs: [], branch: nil, range: [], index: [])
           cmd, opts = git_session('diff', opts: opts)
           op = OptionPartition.new(opts, collect_hash(OPT_GIT[:diff]) + OPT_GIT[:log][:diff], cmd,
-                                   project: self, no: OPT_GIT[:no][:log][:diff])
+                                   project: self, no: OPT_GIT[:no][:log][:diff],
+                                   first: flag == :files ? nil : matchpathspec)
           case flag
           when :files, :view, :between, :contain
             op.delete('--cached')
@@ -1026,7 +1248,7 @@ module Squared
             case flag
             when :view
               op << '--merge-base' if option('merge-base')
-              op << shell_quote(range.first, quote: true) << shell_quote(range.last, quote: true)
+              op.merge(range)
             when :between, :contain
               op.delete('--merge-base')
               op << shell_quote(range.join(flag == :between ? '..' : '...'))
@@ -1049,82 +1271,99 @@ module Squared
           source(exception: op.arg?('exit-code'))
         end
-        def commit(flag, *, refs: [], message: nil, pass: false)
-          message ||= option('message', 'm', prefix: 'git', ignore: false)
-          amend = flag.to_s.start_with?('amend')
+        def commit(flag, opts = [], refs: [], ref: nil, squash: nil, pick: nil, message: nil, pass: false)
+          fixup = flag == :fixup
+          amend = !fixup && flag.to_s.start_with?('amend')
+          unless flag == :add || pick == 'reword'
+            pathspec = if flag == :all || ((fixup || amend) && refs.size == 1 && refs.first == '*')
+                         '--all'
+                       elsif (refs = projectmap(refs)).empty?
+                         raise_error 'no qualified pathspec'
+                       else
+                         "-- #{refs.join(' ')}"
+                       end
+          end
+          if fixup
+            source git_session('commit', basic_option('fixup', "#{pick ? "#{pick}:" : ''}#{ref}"), pathspec)
+            source git_output('rebase --autosquash', squash) if squash.is_a?(String)
+            return
+          end
+          message ||= messageopt
           if !message && !amend
             return if pass
-            raise_error('missing message', hint: 'GIT_MESSAGE="description"')
+            message = readline('Enter message', force: true)
           end
-          pathspec = if flag == :all || (amend && refs.size == 1 && refs.first == '*')
-                       '--all'
-                     elsif (refs = projectmap(refs)).empty?
-                       raise_error 'no qualified pathspec'
-                     else
-                       "-- #{refs.join(' ')}"
-                     end
-          origin = nil
           branch = nil
+          origin = nil
           upstream = nil
+          cmd, opts = git_session('add', opts: opts)
+          op = OptionPartition.new(opts, OPT_GIT[:add], cmd, project: self, first: matchpathspec)
+          op << '--verbose' if verbose
+          dryrun = dryrun?
+          format = '%(if)%(HEAD)%(then)%(refname:short)...%(upstream:short)...%(upstream:track)%(end)'
           git_spawn 'fetch --no-tags --quiet'
-          git_spawn('branch -vv --list', stdout: 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 = git_spawn('log -n1 --format=%h%d').first
-                if out =~ /^#{r[2]} \(HEAD -> #{Regexp.escape(branch)}, (.+?)\)$/
-                  split_escape($1).each do |s|
-                    next unless s.end_with?("/#{branch}")
-                    origin = s[0, s.size - branch.size - 1]
-                    break
-                  end
+          foreachref('heads', format: format).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
+              break if dryrun
+              unless (origin = option('upstream', prefix: 'git', ignore: false))
+                if (origin = choice_refs('Choose an upstream', 'remotes', attempts: 1, force: false))
+                  git_spawn 'branch', quote_option('set-upstream-to', origin)
+                else
+                  origin = readline('Enter an upstream', force: true)
                 end
               end
-              upstream = true if origin
+              raise_error('missing remote name', hint: origin) unless origin.include?('/')
+              upstream = true
             end
             break
           end
-          raise_error 'work tree is not usable' unless origin && branch
-          cmd = git_session('commit', option('dry-run') && '--dry-run', options: false)
-          if amend
-            cmd << '--amend'
+          if pathspec
+            op << pathspec
           else
-            cmd.delete('--amend')
+            append_pathspec op.extras
+          end
+          co = git_session('commit', options: false)
+          pu = git_output 'push', upstream && '--set-upstream'
+          if dryrun
+            op.delete('--dry-run')
+            co << '--dry-run'
+            pu << '--dry-run'
           end
+          co << '--amend' if amend
           if message
             append_message message
           elsif flag == :'amend-orig' || option('edit', equals: '0')
-            cmd << '--no-edit'
-          end
-          a = git_output 'add', '--verbose'
-          b = git_output 'push', upstream && '--set-upstream'
-          if dryrun?
-            a << '--dry-run'
-            b << '--dry-run'
+            co << '--no-edit'
           end
-          a << pathspec
-          b << '--force-with-lease' if amend
-          b << origin << branch
+          pu << '--force-with-lease' if amend
+          pu.merge(repotrack(origin, branch))
           puts if pass
-          source a
-          source cmd
-          source b
+          source op
+          source co
+          source pu
         end
-        def merge(flag, opts = [], command: nil)
+        def merge(flag, opts = [], command: nil, branch: nil)
           cmd, opts = git_session('merge', opts: opts)
           case flag
           when :commit, :'no-commit'
             op = OptionPartition.new(opts, OPT_GIT[:merge], cmd, project: self, no: OPT_GIT[:no][:merge])
             raise_error 'no branch/commit' if op.empty?
             op << "--#{flag}" << '--'
-            append_commit(*op.extras)
+            if branch
+              op << branch
+              op.clear(pass: false)
+            else
+              append_commit(*op.extras)
+            end
           else
             return unless VAL_GIT[:merge][:send].include?(command)
@@ -1133,7 +1372,7 @@ module Squared
           source
         end
-        def branch(flag = nil, opts = [], refs: [], ref: nil, target: nil)
+        def branch(flag = nil, opts = [], refs: [], ref: nil, target: nil, remote: nil)
           cmd, opts = git_session('branch', opts: opts)
           stdout = false
           case flag
@@ -1149,43 +1388,46 @@ module Squared
                      end
             end
             cmd << '--force' if option('force')
-          when :set
-            return unless ref
+            cmd << shell_quote(target)
+            cmd << shell_quote(ref) if ref
+          when :track
+            raise_error('invalid upstream', hint: ref) unless ref.include?('/')
             if ref.start_with?('^')
-              cmd << '--unset-upstream' << shell_escape(ref[1..-1])
-              target = nil
+              cmd << '--unset-upstream' << shell_quote(ref[1..-1])
+              remote = false
               stdout = true
             else
               cmd << quote_option('set-upstream-to', ref)
+              cmd << shell_quote(target) if target
             end
-            ref = nil
           when :delete
-            force, list = refs.partition { |val| val.match?(/^[\^~]/) }
+            remote&.each do |val|
+              source git_output('push', '--delete', *val.split('/', 2).map { |s| shell_quote(s) })
+            end
+            force, list = refs.partition { |val| val.match?(/^[~^]/) }
             force.each do |val|
-              dr = val[0, 3]
+              dr = val[0, 2]
               d = dr.include?('^') ? '-D' : '-d'
-              r = dr.include?('~') ? '-r' : nil
-              source git_output('branch', d, r, shell_quote(val.sub(/^[\^~]+/, '')))
+              r = '-r' if dr.include?('~')
+              source git_output('branch', d, r, shell_quote(val.sub(/^[~^]+/, '')))
             end
             return if list.empty?
             cmd << '-d'
-            list.each { |val| cmd << shell_quote(val) }
+            append_value list
+            remote = nil
           when :move, :copy
             flag = "-#{flag.to_s[0]}"
             cmd << (option('force') ? flag.upcase : flag)
             refs.compact.each { |val| cmd << shell_quote(val) }
             stdout = true
-          when :edit
-            cmd << '--edit-description'
           when :current
             cmd << '--show-current'
             source(banner: verbosetype > 1, stdout: true)
             return
           when :list
             op = OptionPartition.new(opts, OPT_GIT[:branch], cmd << '--list',
-                                     project: self, no: OPT_GIT[:no][:branch], single: /^v+$/)
+                                     project: self, no: OPT_GIT[:no][:branch], single: /\Av+\z/)
             op.each { |val| op << shell_quote(val) }
             out, banner, from = source(io: true)
             print_item banner
@@ -1196,7 +1438,7 @@ module Squared
             list_result(ret, 'branches', from: from)
             return
           else
-            head = git_spawn('rev-parse --abbrev-ref HEAD').first.chomp
+            head = git_spawn('rev-parse --abbrev-ref HEAD').chomp
             if head.empty?
               ret = 0
             else
@@ -1212,8 +1454,8 @@ module Squared
                 if (r1 = r[1]) && r1 =~ /^(.+):(?: ([a-z]+) (\d+),)? ([a-z]+) (\d+)$/
                   write = ->(s1, s2) { "#{s1.capitalize.rjust(7)}: #{sub_style(s2, styles: theme[:warn])}" }
                   r1 = $1
-                  r2 = $2 && write.($2, $3)
-                  r3 = write.($4, $5)
+                  r2 = $2 && write.call($2, $3)
+                  r3 = write.call($4, $5)
                 end
                 r1 = nil if r1 == "origin/#{data[0]}"
                 [" Branch: #{a + (r1 ? " (#{r1})" : '')}", r2, r3, " Commit: #{b}", "Message: #{r[2]}"]
@@ -1227,15 +1469,46 @@ module Squared
             end
             return
           end
-          cmd << shell_escape(target) if target
-          cmd << shell_escape(ref) if ref
-          source(stdout: stdout)
+          return unless success?(source(stdout: stdout))
+          if !ref
+            print_success if flag == :create
+          elsif remote && target
+            source git_output('push', '-u', shell_quote(ref.split('/', 2).first), shell_quote(target))
+          end
         end
-        def restore(flag, opts = [])
-          cmd, opts = git_session('restore', "--#{flag}", opts: opts)
-          op = OptionPartition.new(opts, OPT_GIT[:restore], cmd, project: self, no: OPT_GIT[:no][:restore])
-          append_pathspec(op.extras, pass: false)
+        def switch(flag, opts = [], target: nil, commit: nil, track: nil)
+          cmd = git_session('switch', opts: opts).first
+          case flag
+          when :create
+            c = 'c'
+            if target.start_with?('^')
+              target = target[1..-1]
+              c = c.upcase
+            end
+            cmd << quote_option(c, target)
+            cmd << case (track ||= option('track', ignore: false))
+                   when 'n', 'N', '0', 'false'
+                     '--no-track'
+                   when 'y', 'Y', '1', 'true'
+                     '--track'
+                   when 'direct', 'inherit'
+                     basic_option('track', track)
+                   end
+          when :detach, :merge
+            cmd << "--#{flag}"
+          end
+          cmd << '--force' if option('force')
+          append_head commit
+          source
+        end
+        def restore(flag, opts = [], commit: nil, files: nil)
+          cmd, opts = git_session('restore', shell_option(flag, commit, escape: false, force: false), opts: opts)
+          op = OptionPartition.new(opts, OPT_GIT[:restore], cmd, project: self, no: OPT_GIT[:no][:restore],
+                                                                 first: matchpathspec)
+          append_pathspec(op.extras + (files || []), pass: false)
           source(sync: false, stderr: true)
         end
@@ -1244,14 +1517,13 @@ module Squared
           case flag
           when :textconv
             cmd << '--textconv'
-            append_value(files.map { |val| Dir[val] }
-                              .flatten
+            append_value(files.flat_map { |val| Dir[val] }
                               .select { |val| projectpath?(val) }
                               .map! { |val| shell_quote("HEAD:#{val}") })
             source(banner: false)
             return
           when :oneline
-            format = flag.to_s
+            format = 'oneline'
           end
           if format
             case (val = format.downcase)
@@ -1268,21 +1540,12 @@ module Squared
           op = OptionPartition.new(opts, OPT_GIT[:show] + OPT_GIT[:diff][:show] + OPT_GIT[:log][:diff], cmd,
                                    project: self,
                                    no: OPT_GIT[:no][:show] + collect_hash(OPT_GIT[:no][:log], pass: [:base]))
-          unless val == 'oneline' && op.arg?('abbrev-commit')
-            op << basic_option('abbrev', val) if (val = option('abbrev')) && val.to_i > 0
-            banner = true
-          end
           op.append(delim: true)
-          source(exception: false, banner: banner)
+          source(exception: false, banner: flag != :oneline)
         end
         def rev_parse(flag, opts = [], ref: nil, size: nil)
           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')
@@ -1290,9 +1553,14 @@ module Squared
           when :branch
             cmd << '--abbrev-ref'
             append_commit(ref, head: true)
-          else
-            op = OptionPartition.new(opts, OPT_GIT[:rev_parse][flag], cmd, project: self)
-            op.append(escape: op.arg?('sq-quote'))
+          when :output
+            if opts.delete('sq-quote')
+              cmd << '--sq-quote'
+              args = true
+            end
+            op = OptionPartition.new(opts, OPT_GIT[:rev_parse], cmd, project: self, no: OPT_GIT[:no][:rev_parse],
+                                                                     args: args)
+            op.append(escape: args)
           end
           source(banner: verbosetype > 1)
         end
@@ -1319,18 +1587,10 @@ module Squared
         def git(flag, opts = [])
           cmd, opts = git_session(flag, opts: opts)
-          op = OptionPartition.new(opts, OPT_GIT[flag], cmd, project: self, no: OPT_GIT[:no][flag])
-          sync = false
-          stderr = true
+          list = OPT_GIT[:git].fetch(flag, []) + OPT_GIT.fetch(flag, [])
+          op = OptionPartition.new(opts, list, cmd, project: self, no: OPT_GIT[:no][flag],
+                                                    first: flag == :revert ? nil : matchpathspec)
           case flag
-          when :clean
-            refs = projectmap(op.extras)
-            unless refs.empty?
-              op << '--'
-              op.merge(refs)
-            end
-            sync = true
-            stderr = false
           when :revert
             if VAL_GIT[:rebase][:send].any? { |val| op.arg?(val) }
               op.clear
@@ -1339,14 +1599,29 @@ module Squared
             else
               append_commit(*op.extras)
             end
+          when :add, :clean
+            if flag == :add && op.empty? && !op.arg?('pathspec-from-file')
+              files = []
+              red = color(:red)
+              git_spawn('status -s --porcelain -uall', stdout: false).each do |line|
+                next unless line =~ /^.(.) (.+)$/
+                files << "#{sub_style($1, styles: red)} #{$2}"
+              end
+              files = choice_index('Select files', files, multiple: true, force: true, trim: /^\S+\s/, accept: 'Add?')
+            end
+            append_pathspec(files || op.extras)
+            verbose = flag == :add && !op.arg?('verbose')
+            print_success if success?(source) && verbose
+            return
           when :mv
-            refs = projectmap(op.extras)
+            refs = projectmap op.extras
             raise_error 'no source/destination' unless refs.size > 1
             op.merge(refs)
           when :rm
-            append_pathspec(op.extras, expect: true)
+            append_pathspec(op.extras, expect: !op.arg?('pathspec-from-file'))
           end
-          source(sync: sync, stderr: stderr)
+          source(sync: false, stderr: true)
         end
         def clone?
@@ -1365,43 +1640,47 @@ module Squared
         def source(cmd = @session, exception: true, io: false, sync: true, stdout: false, stderr: false, banner: true,
                    multiple: false, sub: nil)
+          cmd = cmd.target if cmd.is_a?(OptionPartition)
           banner = nil if multiple && banner
           if cmd.respond_to?(:done)
             if io && banner == false
               from = nil
-            elsif !from && (from = cmd.drop(1).find { |val| val.match?(/^[a-z][a-z\-]{2,}$/) })
+            elsif !from && (from = cmd.drop(1).find { |val| val.match?(/\A[a-z][a-z\-]{2,}\z/) })
               from = :"git:#{from}"
             end
             banner &&= cmd.temp { |val| val.start_with?('--work-tree') || val.start_with?('--git-dir') }
           end
-          cmd = session_done(cmd)
+          cmd = session_done cmd
           log&.info cmd
           on :first, from
           banner = if banner
                      format_banner((banner.is_a?(String) ? banner : cmd).gsub(File.join(path, ''), ''), banner: true)
                    end
           begin
-            return [stdout ? `#{cmd}` : IO.popen(cmd), banner, from] if io
+            if io
+              return `#{cmd}` if stdout
+              return banner ? [IO.popen(cmd), banner, from] : IO.popen(cmd)
+            end
             if stdin? ? sync : stdout
               print_item banner unless multiple
               ret = `#{cmd}`
               if !ret.empty?
                 puts ret
-              elsif banner && stdout && !stdin?
-                puts 'Success'
+              elsif success?(!banner.nil?)
+                print_success
               end
             elsif sync || (!exception && !stderr)
               print_item banner unless multiple
-              shell(cmd, exception: exception)
+              ret = shell(cmd, exception: exception)
             else
               require 'open3'
               if stderr
                 Open3.popen3(cmd) do |_, out, err|
-                  ret = write_lines(out, banner: banner, sub: sub, pass: true)
-                  if ret == 0
-                    ret = write_lines(err, banner: banner)
-                    puts 'Success' if ret == 0 && banner && !stdin?
+                  n = write_lines(out, banner: banner, sub: sub, pass: true)
+                  if n == 0
+                    n = write_lines(err, banner: banner)
+                    print_success if success?(n == 0 && !banner.nil?)
                   else
                     write_lines(err, loglevel: Logger::DEBUG)
                   end
@@ -1416,8 +1695,10 @@ module Squared
             raise if exception && ret != true
             warn log_message(Logger::WARN, e, pass: true) if warning?
+            nil
           else
             on :last, from
+            ret
           end
         end
@@ -1458,7 +1739,7 @@ module Squared
               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}",
-                                sub: { pat: /\A(\d+)(.+)\z/, styles: styles })
+                                sub: { pat: /\A(\d+)(.+)\z/m, styles: styles })
             else
               puts empty_status("No #{type} were #{action}", 'grep', grep.is_a?(Array) ? case grep.size
                                                                                          when 0
@@ -1471,27 +1752,55 @@ module Squared
           on :last, from
         end
-        def status_digest(*args, algorithm: Digest::SHA256, **kwargs)
+        def choice_refs(msg, *type, format: nil, sort: '-creatordate', count: true, short: true, **kwargs)
+          type << 'heads' if type.empty?
+          unless format
+            format = +"%(refname#{short ? ':short' : ''})"
+            if type.include?('heads') || type.include?('tags')
+              format += '%(if)%(HEAD)%(then) *%(end)'
+              trim = /\s+\*\z/
+            end
+          end
+          args = []
+          args << quote_option('sort', sort) if sort
+          args << shell_option('count', env('GIT_COUNT', ARG[:CHOICE])) if count
+          choice_index(msg, foreachref(type, *args, format: format), trim: trim, **kwargs)
+        end
+        def choice_commit(count: true, reflog: true, force: true, **kwargs)
+          kwargs[:attempts] ||= 1 unless force
+          cmd = git_output(reflog && env('GIT_REFLOG') ? 'reflog' : 'log')
+          cmd << quote_option('format', '(%h) %s')
+          cmd << basic_option('max-count', env('GIT_COUNT', ARG[:CHOICE])) if count
+          choice_index('Choose a commit', git_spawn(cmd, stdout: false), column: /\((\w+)\)/, force: force, **kwargs)
+        end
+        def choice_remote(force: false, **kwargs)
+          kwargs[:attempts] ||= 1 unless force
+          choice_index('Select a remote', git_spawn('remote', stdout: false), force: force, **kwargs)
+        end
+        def status_digest(*args, algorithm: nil, **kwargs)
+          require 'digest'
+          algorithm ||= Digest::SHA256
           glob = kwargs.fetch(:include, [])
           pass = kwargs.fetch(:exclude, [])
           ret = {}
-          git_spawn('status -s --porcelain', *args, stdout: false).first.each do |line|
+          git_spawn('status -s --porcelain', *args, stdout: false).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)))
+            ret[file] = algorithm.hexdigest(File.read(path + file))
           end
           ret
         end
-        def git_spawn(*cmd, stdout: true)
-          source(git_output(*cmd), io: true, banner: false, stdout: stdout)
-        end
         def append_pull(opts, list, target: @session, flag: nil, no: nil, remote: nil)
           target << '--force' if option('force', target: target)
           append_submodules(target: target)
+          return if !remote && opts.empty?
           refspec = []
           op = OptionPartition.new(opts, remote ? list + ['refspec=v'] : list, target, project: self, no: no)
           op.each do |opt|
@@ -1543,7 +1852,7 @@ module Squared
             option_clear files
           else
             if files.empty? && (val = option('pathspec', target: target))
-              files = split_escape(val)
+              files = split_escape val
             end
             files = projectmap(files, parent: parent, pass: pass)
             if !files.empty?
@@ -1554,12 +1863,13 @@ module Squared
           end
         end
-        def append_message(val, target: @session)
-          target << quote_option('message', val) unless val.to_s.empty?
+        def append_message(val = nil, target: @session)
+          val = messageopt if val.to_s.empty?
+          target << quote_option('message', val) if val
         end
         def append_head(val = nil, target: @session)
-          return target << val if val
+          return target << shell_quote(val) if val
           append_first('head', 'tree-ish', 'object', target: target, flag: false, ignore: false)
         end
@@ -1568,22 +1878,33 @@ module Squared
           return unless (val = option('recurse-submodules', target: target, ignore: false))
           if from == :clone
-            projectmap(split_escape(val)).each do |path|
-              target << basic_option('recurse-submodules', path)
+            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
             end
-            target
           else
             target << case val
                       when 'no', '0', 'false'
                         '--no-recurse-submodules'
                       when 'yes', 'on-demand'
-                        "--recurse-submodules#{from == :reset ? '' : "=#{val}"}"
+                        "--recurse-submodules=#{val}"
                       else
                         '--recurse-submodules'
                       end
           end
         end
+        def foreachref(path, *args, format: nil)
+          path = as_a(path).map! { |val| "refs/#{val}" }
+          git_spawn('for-each-ref', format && quote_option('format', format), *args, *path, stdout: false)
+        end
         def git_session(*cmd, opts: nil, worktree: true, **kwargs)
           dir = worktree ? ["--work-tree=#{shell_quote(path)}", "--git-dir=#{shell_quote(gitpath)}"] : []
           return session('git', *dir, *cmd, **kwargs) unless opts
@@ -1597,10 +1918,14 @@ module Squared
           git_session(*cmd, main: false, options: false, **kwargs)
         end
+        def git_spawn(*cmd, stdout: true)
+          source(cmd.first.is_a?(Set) ? cmd.first : git_output(*cmd), io: true, banner: false, stdout: stdout)
+        end
         def dryrun?(*, target: @session, **)
           return false unless target
-          target.include?('--dry-run')
+          target.include?('--dry-run') || !option('dry-run', target: target).nil?
         end
         def quiet?(target: @session)
@@ -1610,11 +1935,36 @@ module Squared
         end
         def gitpath
-          basepath '.git'
+          path + '.git'
+        end
+        def repotrack(origin, branch, quote: true)
+          i = origin.index('/')
+          branch = "#{branch}:#{origin[i + 1..-1]}" unless origin.end_with?("/#{branch}")
+          ret = [origin[0..i - 1], branch]
+          quote ? ret.map! { |val| shell_quote(val) } : ret
         end
         def commithash(val)
-          val[/^#\{(\h{5,40})\}$/, 1]
+          val[/:(\h{5,40})\z/, 1] || val[/\A#\{(\h{5,40})\}\z/, 1]
+        end
+        def commithead(val)
+          return val unless (s = matchhead(val))
+          s.match?(/^\d/) ? "@~#{s}" : "@#{s}"
+        end
+        def matchhead(val)
+          val && val =~ /^(?:(?:HEAD|@)([~^]\d*)?|H(\d+))$/ ? $2 || $1 || '' : nil
+        end
+        def matchpathspec
+          [/\A[^a-z\d-]+/i, %r{\A[^=\\/*]*[\\/*]}]
+        end
+        def messageopt
+          option('message', 'm', prefix: 'git', ignore: false)
         end
         def threadargs