squared 0.4.36 → 0.5.0

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

@@ -5,37 +5,33 @@ module Squared
     module Project
       class Node < Git
         OPT_NPM = {
-          common: %w[dry-run=!? force=!? loglevel=b include-workspace-root=!? workspaces=!? w|workspace=v].freeze,
-          install: %w[package-lock-only=!? prefer-dedupe=!? E|save-exact=!? before=q cpu=b libc=b os=b].freeze,
-          install_base: %w[audit=! bin-links=! foreground-scripts=!? fund=! ignore-scripts=!? install-links=!?
-                           package-lock=! strict-peer-deps=!? include=b install-strategy=b omit=b].freeze,
+          common: %w[dry-run include-workspace-root workspaces=b? w|workspace=v].freeze,
+          install: %w[prefer-dedupe package-lock-only cpu=b libc=b os=b].freeze,
+          install_base: %w[ignore-scripts install-links strict-peer-deps include=b omit=b install-strategy=b].freeze,
           install_no: %w[audit bin-links fund package-lock].freeze,
-          install_as: %w[no-save B|save-bundle D|save-dev O|save-optional save-peer P|save-prod g|global=!?
-                         S|save=!?].freeze,
-          run: %w[foreground-scripts=!? if-present=!? ignore-scripts=!? script-shell=p].freeze,
+          install_as: %w[foreground-scripts g|global no-save save save-bundle save-dev E|save-exact save-optional
+                         save-peer S|save-prod].freeze,
+          run: %w[foreground-scripts if-present ignore-scripts script-shell=p].freeze,
           exec: %w[c|call=q package=b].freeze,
-          pack: %w[ignore-scripts=!? json=!? pack-destination=p].freeze
+          pack: %w[json ignore-scripts pack-destination=p].freeze
         }.freeze
         OPT_PNPM = {
-          common: %w[aggregate-output color ignore-workspace-root-check no-color stream use-stderr C|dir=p loglevel=b
-                     r|recursive w|workspace-root].freeze,
-          cpu: %w[cpu=b libc=b os=b].freeze,
+          common: %w[aggregate-output color no-color stream use-stderr C|dir=p loglevel=b w|workspace-root].freeze,
           filter: %w[fail-if-no-match changed-files-ignore-pattern=q filter=q filter-prod=q test-pattern=q].freeze,
           install: %w[fix-lockfile force ignore-pnpmfile ignore-workspace lockfile-only merge-git-branch-lockfiles
-                      optimistic-repeat-install no-hoist no-lockfile no-optional prefer-frozen-lockfile resolution-only
-                      shamefully-hoist side-effects-cache side-effects-cache-readonly s|silent strict-peer-dependencies
+                      no-hoist no-lockfile no-optional prefer-frozen-lockfile resolution-only shamefully-hoist
+                      side-effects-cache side-effects-cache-readonly s|silent strict-peer-dependencies
                       use-running-store-server use-store-server child-concurrency=i hoist-pattern=q lockfile-dir=p
                       modules-dir=p network-concurrency=i package-import-method=b public-hoist-pattern=q
                       reporter=b].freeze,
-          install_base: %w[dangerously-allow-all-builds global-dir ignore-scripts offline prefer-offline store-dir=p
-                           virtual-store-dir=p].freeze,
+          install_base: %w[global-dir ignore-scripts offline prefer-offline store-dir=p virtual-store-dir=p].freeze,
           install_no: %w[frozen-lockfile verify-store-integrity].freeze,
-          install_as: %w[D|dev no-optional P|prod].freeze,
-          update: %w[g|global i|interactive L|latest depth=i].freeze,
+          install_as: %w[D|dev global-dir no-optional P|prod r|recursive].freeze,
+          update: %w[global interactive latest depth=i].freeze,
           dedupe: %w[check].freeze,
-          run: %w[if-present no-bail parallel report-summary reporter-hide-prefix resume-from
-                  sequential].freeze,
-          exec: %w[no-reporter-hide-prefix parallel report-summary resume-from c|shell-mode].freeze,
+          run: %w[if-present no-bail parallel r|recursive report-summary reporter-hide-prefix resume-from sequential
+                  stream use-stderr].freeze,
+          exec: %w[no-reporter-hide-prefix parallel r|recursive report-summary resume-from c|shell-mode].freeze,
           pack: %w[json pack-destination=p pack-gzip-level=i].freeze
         }.freeze
         OPT_YARN = {
@@ -98,10 +94,11 @@ module Squared
           'add' => nil,
           'run' => nil,
           'exec' => nil,
+          'nvm' => nil,
           'pack' => nil
         })
 
-        def initialize(*, init: nil, **kwargs)
+        def initialize(*, **kwargs)
           super
           if @pass.include?(Node.ref)
             initialize_ref Node.ref
@@ -110,8 +107,8 @@ module Squared
             initialize_build(Node.ref, prod: prod?, **kwargs)
             initialize_env(**kwargs)
           end
-          @dependfile = basepath 'package.json'
-          @pm = { __: init }
+          @dependfile = @path + 'package.json'
+          @pm = {}
         end
 
         def ref
@@ -120,35 +117,39 @@ module Squared
 
         def populate(*, **)
           super
-          return unless (outdated? && ref?(Node.ref)) || @only
+          return unless outdated? && ref?(Node.ref)
 
           namespace name do
             Node.subtasks do |action, flags|
-              next if task_pass?(action)
+              next if @pass.include?(action)
 
               if flags.nil?
                 case action
                 when 'add'
                   format_desc action, nil, 'save?=prod|dev|optional|peer,name+'
                   task action, [:save] do |_, args|
-                    packages = if args.save =~ /\A(=)?(prod|dev|optional|peer)\z/
-                                 exact = !$1.nil?
-                                 save = $2
-                                 args.extras
-                               else
-                                 save = 'prod'
-                                 args.to_a
-                               end
+                    save = param_guard(action, 'save', args: args, key: :save)
+                    if save.start_with?('=')
+                      exact = true
+                      save = save[1..-1]
+                    end
+                    case save
+                    when 'prod', 'dev', 'optional', 'peer'
+                      packages = args.to_a.drop(1)
+                    else
+                      save = 'prod'
+                      packages = args.to_a
+                    end
                     param_guard(action, 'name', args: packages)
                     depend(:add, packages: packages, save: save, exact: exact)
                   end
                 when 'run'
                   next if (list = read_scripts).empty?
 
-                  format_desc action, nil, "script,opts*|#{indexchar}index+|#,pattern*"
+                  format_desc action, nil, 'script,opts*|^index+|#,pattern*'
                   task action, [:script] do |_, args|
                     if args.script == '#'
-                      format_list(list, "run[#{indexchar}N]", 'scripts', grep: args.extras, from: dependfile)
+                      format_list(list, 'run[^N]', 'scripts', grep: args.extras, from: dependfile.to_s)
                     else
                       args = param_guard(action, 'script', args: args.to_a)
                       opts = []
@@ -159,8 +160,7 @@ module Squared
                           elsif exception
                             indexerror n, list
                           else
-                            log.warn "run script #{n} of #{list.size} (out of range)"
-                            next
+                            next log.warn "run script #{n} of #{list.size} (out of range)"
                           end
                           run compose(val, script: true)
                         else
@@ -186,7 +186,7 @@ module Squared
                   format_desc action, nil, 'pkg/cmd,opts*,args*'
                   task action, [:package] do |_, args|
                     if (package = args.package)
-                      args = args.extras
+                      args = args.to_a.drop(1)
                       if pnpm?
                         pre = ->(ch) { "-#{ch}" if (ch = args.delete(ch)) }
                         cmd = session 'pnpm', pre.call('r'), pre.call('c'), 'exec'
@@ -211,6 +211,17 @@ module Squared
                     end
                     run(from: :exec)
                   end
+                when 'nvm'
+                  next unless ENV['NVM_DIR']
+
+                  format_desc action, nil, 'version,args*'
+                  task action, [:version] do |_, args|
+                    version = param_guard(action, 'version', args: args, key: :version)
+                    args = args.to_a.drop(1)
+                    args << readline('Enter command', force: true) if args.empty?
+                    args.prepend(File.join(ENV['NVM_DIR'], 'nvm-exec'))
+                    run(args.join(' '), { 'NODE_VERSION' => version }, banner: false, from: :nvm)
+                  end
                 when 'pack'
                   format_desc action, nil, 'opts*'
                   task action do |_, args|
@@ -222,12 +233,12 @@ module Squared
                   flags.each do |flag|
                     case action
                     when 'outdated'
-                      format_desc(action, flag, %w[update interactive dry-run], arg: 'opts?')
+                      format_desc(action, flag, %w[prune interactive dry-run].freeze, arg: 'opts?')
                       task flag do |_, args|
                         outdated flag, args.to_a
                       end
                     when 'package'
-                      format_desc(action, flag, 'opts*', after: flag == :dedupe ? nil : 'name*')
+                      format_desc(action, flag, 'opts*', after: flag == :dedupe ? nil : 'names*')
                       task flag do |_, args|
                         package flag, args.to_a
                       end
@@ -248,7 +259,7 @@ module Squared
                       format_desc(action, flag, 'otp?,dry-run?,public|restricted?', before: flag == :tag ? 'tag' : nil)
                       task flag do |_, args|
                         args = args.to_a
-                        dryrun = true if args.delete('dry-run') || args.delete('true') || args.delete('d')
+                        dryrun = true if args.delete('dry-run') || args.delete('d')
                         if args.delete('public') || args.delete('p')
                           access = 'public'
                         elsif args.delete('restricted') || args.delete('r')
@@ -269,10 +280,8 @@ module Squared
           end
         end
 
-        def copy(from: 'build', into: 'node_modules', scope: nil, also: nil, create: nil, files: nil, workspace: false,
+        def copy(from: 'build', into: 'node_modules', scope: nil, also: nil, create: nil, workspace: false,
                  link: false, force: false, override: false, sync: invoked_sync?('copy'), **kwargs)
-          return if @copy == false
-
           glob = kwargs[:include]
           pass = kwargs[:exclude]
           if @copy && !override
@@ -280,7 +289,6 @@ module Squared
 
             from = @copy[:from] if @copy.key?(:from)
             into = @copy[:into] if @copy.key?(:into)
-            files = @copy[:files] if @copy.key?(:files)
             workspace = @copy[:workspace] if @copy.key?(:workspace)
             link = @copy[:link] if @copy.key?(:link)
             force = @copy[:force] if @copy.key?(:force)
@@ -289,6 +297,8 @@ module Squared
             create = @copy[:create] if @copy.key?(:create)
             glob = @copy[:include] if @copy.key?(:include)
             pass = @copy[:exclude] if @copy.key?(:exclude)
+          elsif @copy == false
+            return
           end
           items = []
           if build? && path != @workspace.home && @workspace.home?
@@ -300,7 +310,6 @@ module Squared
 
           on :first, :copy
           print_item unless @output[0] || !verbose || task_invoked?(/^copy(?::#{Node.ref}|$)/)
-          packed = false
           items.each do |dir|
             case dir
             when Pathname
@@ -338,56 +347,16 @@ module Squared
             end
             next unless from && dest&.directory?
 
-            if from == :npm
-              begin
-                unless packed
-                  require 'open3'
-                  files = pwd_set do
-                    Open3.capture2e(session_output('npm', 'pack --dry-run --no-color', npmname).to_s)
-                         .first
-                         .scan(/^npm notice \d+(?:\.\d+)?[a-z]+ (.+)$/i)
-                         .map { |item| Pathname.new(item.first) }
-                         .select(&:exist?)
-                  end
-                  .concat(Array(files))
-                  packed = true
-                end
-                to = dest.join(into, npmname)
-                to.mkpath
-                log.info "cp npm:#{npmname} #{to}"
-                subdir = []
-                errors = 0
-                files.each do |file|
-                  s, d = file.is_a?(Array) ? file : [file, file]
-                  dest = to + d
-                  unless subdir.include?((target = dest.dirname).to_s)
-                    target.mkpath
-                    subdir << target.to_s
-                  end
-                  begin
-                    FileUtils.cp(basepath(s), dest, verbose: verbosetype > 0)
-                  rescue StandardError => e
-                    print_error e
-                    errors += 1
-                  end
-                end
-              rescue StandardError => e
-                on_error e, :copy
-              else
-                puts message(to, subdir.size, files.size - errors) if verbose
-              end
-              next
-            end
-            glob = Array(glob || '**/*')
+            from = path + from
+            glob = as_a(glob || '**/*')
             target = []
-            from = basepath from
             if workspace
-              Dir.glob(from + '*').each do |path|
-                next unless (path = Pathname.new(path)).directory?
+              from.glob('*').each do |entry|
+                next unless entry.directory?
 
-                sub = if (proj = @workspace.find(path))
+                sub = if (proj = @workspace.find(entry))
                         proj.packagename
-                      elsif (file = path + 'package.json').exist?
+                      elsif (file = entry + 'package.json').exist?
                         begin
                           doc = JSON.parse(file.read)
                         rescue StandardError => e
@@ -398,20 +367,22 @@ module Squared
                         end
                       end
                 if sub
-                  target << [path, dest.join(into, sub)]
+                  target << [entry, dest.join(into, sub)]
                 else
-                  log.debug message("package.json in \"#{path}\"", hint: 'not found')
+                  log.debug message("package.json in \"#{entry}\"", hint: 'not found')
                 end
               end
             else
-              target << [from, dest.join(into, scope || npmname)]
+              target << [from, dest.join(into, scope || project)]
             end
             target.each do |src, to|
               glob.each { |val| log.info "cp #{from + val} #{to}" }
               begin
-                copy_dir(src, to, glob, create: create, link: link, force: force, pass: pass, verbose: verbosetype > 0)
+                copy_dir(src, to, glob, create: create, link: link, force: force, pass: pass, verbose: verbose)
               rescue StandardError => e
-                on_error e, :copy
+                log.error e
+                ret = on(:error, :copy, e)
+                raise if exception && ret != true
               end
             end
           end
@@ -427,58 +398,46 @@ module Squared
 
             if (yarn = dependtype(:yarn)) > 0
               cmd = session 'yarn'
-              if !flag && yarn > 1 && prod?
-                cmd << 'workspaces focus --all --production'
-              elsif flag == :add
+              if flag == :add
                 cmd << 'add'
                 cmd << "--#{save}" unless save == 'prod'
                 cmd << '--exact' if exact
               else
                 cmd << 'install'
-                if yarn == 1
-                  cmd << '--production' if prod?
-                  cmd << '--ignore-engines' unless option('ignore-engines', equals: '0')
-                end
+                cmd << '--ignore-engines' if yarn == 1 && !option('ignore-engines', equals: '0')
               end
             elsif pnpm?
               cmd = session 'pnpm'
               if flag == :add
                 cmd << 'add' << "--save-#{save}"
                 cmd << '--save-exact' if exact
-                option('allow-build') { |val| cmd << quote_option('allow-build', val) }
               else
                 cmd << 'install'
-                cmd << '--prod' if prod?
-                append_platform
               end
-              if (val = option('public-hoist-pattern'))
+              option('public-hoist-pattern', ignore: false) do |val|
                 split_escape(val).each { |opt| cmd << shell_option('public-hoist-pattern', opt) }
               end
               cmd << '--ignore-workspace' if env('NODE_WORKSPACES', equals: '0')
-              cmd << '--dangerously-allow-all-builds' if option('approve-builds')
               append_nocolor
             else
               cmd = session 'npm', 'install'
               if flag == :add
                 cmd << "--save-#{save}"
                 cmd << '--save-exact' if exact
-              else
-                cmd << '--include=prod' if prod?
-                append_platform
+                cmd.merge(packages.map { |pkg| shell_escape(pkg) })
               end
               cmd << '--workspaces=false' if env('NODE_WORKSPACES', equals: '0')
               cmd << '--package-lock=false' if option('package-lock', equals: '0')
               append_nocolor
             end
             append_loglevel
-            cmd.merge(packages.map { |pkg| shell_quote(pkg) }) if flag == :add
-            run(from: flag || :depend, sync: sync)
+            run(from: :depend, sync: sync)
           end
         end
 
         def outdated(flag = nil, opts = [], sync: invoked_sync?('outdated', flag))
           dryrun = opts.include?('dry-run') || opts.include?('d')
-          if pnpm?
+          if pnpm? && read_packagemanager(version: '7.15', update: true)
             cmd = session 'pnpm', 'outdated'
             dryrun ||= dryrun?('pnpm')
           else
@@ -489,14 +448,19 @@ module Squared
             log.info cmd.to_s
             on :first, :outdated
           end
-          banner = format_banner(cmd.temp(dryrun ? '--dry-run' : nil))
+          banner = format_banner(cmd.temp(dryrun ? ' --dry-run' : nil))
           print_item banner if sync
           begin
             data = pwd_set { `#{cmd.temp('--json', '--loglevel=error')}` }
             doc = dependfile.read
             json = JSON.parse(doc)
           rescue StandardError => e
-            on_error(e, :outdated, dryrun: dryrun)
+            log.error e
+            unless dryrun
+              ret = on(:error, :outdated, e)
+              raise if exception && ret != true
+            end
+            warn log_message(Logger::WARN, e, pass: true) if warning?
             return
           else
             dep1 = json['dependencies'] || {}
@@ -523,19 +487,7 @@ module Squared
                 next
               end
               current = val['current'] || file
-              want = val['wanted']
-              unless latest[SEM_VER, 6]
-                case rev
-                when :major
-                  want = latest
-                when :minor
-                  want = latest if latest[SEM_VER, 1] == want[SEM_VER, 1]
-                when :patch
-                  if (g = latest.match(SEM_VER)) && (h = want.match(SEM_VER)) && g[1] == h[1] && g[3] == h[3]
-                    want = latest
-                  end
-                end
-              end
+              want = rev == :major && !latest[SEM_VER, 6] ? latest : val['wanted']
               next unless (current != want || file != want) && (want.match?(SEM_VER) || !file.match?(SEM_VER))
 
               f = semscan file
@@ -592,7 +544,7 @@ module Squared
             found.each_with_index do |item, i|
               a, b, c, d, e = item
               f = inter && (rev != :major || e || semmajor?(item[5], item[6]))
-              if f && !confirm_outdated(a, c, (d / 2.0).ceil, lock: e)
+              if f && !confirm_outdated(a, c, (d / 2.0).ceil, b, lock: e, col1: col1)
                 cur = -1
               else
                 cur = modified
@@ -627,14 +579,10 @@ module Squared
               footer.call(modified, found.size)
             elsif modified > 0
               modified = -1
+              footer.call(0, found.size)
               File.write(dependfile, doc)
-              if opts.include?('update') || opts.include?('u') || option('update')
-                update
-              else
-                footer.call(0, found.size)
-              end
-              printsucc
-              commit(:add, ['package.json'], pass: true)
+              commit(:add, refs: ['package.json'], pass: true)
+              install if opts.include?('prune') || opts.include?('p')
             end
           elsif !avail.empty?
             col1 = size_col.call(avail, 0) + 4
@@ -660,61 +608,61 @@ module Squared
         end
 
         def update(*)
-          package(:update, from: :update)
+          package 'update'
         end
 
-        def publish(flag = nil, *, sync: invoked_sync?('publish', flag), otp: nil, tag: nil, access: nil, dryrun: nil)
-          unless version && !read_packagemanager(:private)
-            print_error('invalid task "publish"', subject: name, hint: version ? 'private' : nil)
+        def publish(flag = nil, *, sync: invoked_sync?('publish', flag), otp: nil, tag: nil, dryrun: nil, access: nil)
+          if read_packagemanager(:private)
+            if warning?
+              warn log_message(Logger::WARN, 'invalid task "publish"', subject: name, hint: 'private', pass: true)
+            end
             return
           end
+          return unless version
+
           cmd = session 'npm', 'publish'
+          dryrun = dryrun?('npm') if dryrun.nil?
           cmd << basic_option('otp', otp) if otp ||= option('otp')
-          cmd << basic_option('tag', tag.tr(' ', '-')) if tag ||= option('tag')
-          case access || option('access')
-          when 'p', 'public'
-            cmd << '--access=public'
-          when 'r', 'restricted'
-            cmd << '--access=restricted'
-          end
-          dryrun ||= dryrun?('npm')
-          if dryrun
-            cmd << '--dry-run'
-          else
-            from = :publish
-            log.info cmd.to_s
-          end
-          if sync
-            run(sync: sync, from: from, interactive: !dryrun && "Publish #{sub_style(npmname, styles: theme[:active])}")
-          else
-            require 'open3'
-            on :first, from
-            pwd_set(from: from, dryrun: dryrun) do
-              cmd = session_done cmd
-              Open3.popen2e(cmd) do |_, out|
-                write_lines(out,
-                            banner: format_banner(cmd),
-                            sub: npmnotice + [{ pat: /^(.+)(Tarball .+)$/, styles: color(:bright_blue), index: 2 }])
+          cmd << basic_option('tag', tag) if tag ||= option('tag')
+          cmd << basic_option('access', access) if access ||= option('access')
+          if verbose
+            if dryrun
+              cmd << '--dry-run'
+            else
+              log.info cmd.to_s
+            end
+            unless sync
+              on :first, :publish unless dryrun
+              pwd_set(from: :publish) do
+                require 'open3'
+                banner = format_banner cmd.to_s
+                Open3.popen2e(cmd.done) do |_, out|
+                  write_lines(out, sub: npmnotice + [pat: /^(.+)(Tarball .+)$/, styles: color(:blue), index: 2],
+                                   banner: banner)
+                end
               end
+              on :last, :publish unless dryrun
+              return
             end
-            on :last, from
+          elsif dryrun
+            return
           end
+          run(from: :publish, sync: sync)
         end
 
-        def package(flag, opts = [], from: nil)
+        def package(flag, opts = [])
           workspace.rev_clear(name)
           if (yarn = dependtype(:yarn)) > 0
             cmd = session 'yarn', if flag == :update
-                                    yarn == 1 ? 'upgrade' : 'up'
+                                    flag = yarn == 1 ? 'upgrade' : 'up'
                                   else
-                                    yarn == 1 && flag == :dedupe ? 'install' : flag
+                                    flag
                                   end
             op = OptionPartition.new(opts, if yarn == 1
-                                             OPT_YARN.fetch(flag == :dedupe ? :install : flag, []) + OPT_YARN[:common]
+                                             OPT_YARN.fetch(flag, []) + OPT_YARN[:common]
                                            else
                                              OPT_BERRY[flag]
                                            end, cmd, project: self)
-            op << '--ignore-engines' if yarn == 1 && !option('ignore-engines', equals: '0')
             op.clear
             append_loglevel
           else
@@ -722,12 +670,11 @@ module Squared
               cmd = session 'pnpm', flag
               list = OPT_PNPM[:install_base] + OPT_PNPM.fetch(flag, []) + OPT_PNPM[:common]
               list.concat(OPT_PNPM[:install_as] + OPT_PNPM[:filter]) unless flag == :dedupe
-              list.concat(OPT_PNPM[:cpu]) unless flag == :update
               no = OPT_PNPM[:"#{flag}_no"]
             else
               cmd = session 'npm', flag
               list = OPT_NPM[:install_base] + OPT_NPM.fetch(flag, []) + OPT_NPM[:common]
-              list.concat(OPT_NPM[:install_as]) if flag == :install || flag == :update
+              list.concat(OPT_NPM[:install_as]) unless flag == :dedupe
               no = OPT_NPM[:install_no]
             end
             op = OptionPartition.new(opts, list, cmd, no: no, project: self)
@@ -735,7 +682,7 @@ module Squared
               if opt =~ op.values
                 case $1
                 when 'w', 'workspace'
-                  op << ($2.match?(%r{[\\/]}) ? quote_option($1, basepath($2)) : shell_option($1, $2))
+                  op << ($2.match?(%r{[\\/]}) ? quote_option($1, path + $2) : shell_option($1, $2))
                 end
               elsif opt.include?('=')
                 op.errors << opt
@@ -744,17 +691,16 @@ module Squared
               end
             end
             op.swap
-            append_platform if flag == :install
             append_nocolor
             append_loglevel
-            if flag == :dedupe || pnpm?
+            if flag == :dedupe
               op.clear
             else
-              op.append(quote: true)
+              op.append(escape: true)
             end
+            op.clear(errors: true)
           end
-          op.clear(errors: true)
-          run(from: from || :"package:#{flag}")
+          run(from: :"package:#{flag}")
         end
 
         def bump(flag, val = nil)
@@ -768,17 +714,14 @@ module Squared
             when :major
               if seg[0] != '0' || seg[2].nil?
                 seg[0] = seg[0].succ
-                seg[2] = '0'
               else
                 seg[2] = seg[2].succ
               end
-              seg[4] = '0'
             when :minor
               if seg[0] == '0'
                 seg[4] &&= seg[4].succ
               else
                 seg[2] = seg[2].succ
-                seg[4] &&= '0'
               end
             when :patch
               seg[4] &&= seg[4].succ
@@ -794,22 +737,24 @@ module Squared
                 log.info "bump version #{cur} to #{val} (#{flag})"
                 on :first, :bump
               end
-              if stdin?
-                puts val
-              elsif verbose
+              if verbose
                 major = flag == :major
                 emphasize("version: #{val}", title: name, border: borderstyle, sub: [
                   headerstyle,
                   { pat: /\A(version:)( )(\S+)(.*)\z/, styles: color(major ? :green : :yellow), index: 3 },
                   { pat: /\A(version:)(.*)\z/, styles: theme[major ? :major : :active] }
                 ])
+              elsif stdin?
+                puts val
               end
               on :last, :bump unless dryrun?
             else
               raise_error('version not found', hint: dependfile)
             end
           rescue StandardError => e
-            on_error(e, :bump, dryrun: dryrun?)
+            log.debug e
+            ret = on(:error, :bump, e)
+            raise if exception && ret != true
           end
         end
 
@@ -819,7 +764,7 @@ module Squared
           cmd = session dependbin, 'pack'
           if dependtype(:yarn) > 1
             op = OptionPartition.new(opts, OPT_BERRY[:pack], cmd, project: self)
-            op.append?('out', Pathname.pwd + "#{project}-#{version}.tgz")
+            op << quote_option('out', Pathname.pwd + "#{project}-#{version}.tgz") unless op.arg?('out')
           else
             op = OptionPartition.new(opts, pnpm? ? OPT_PNPM[:pack] : OPT_NPM[:pack] + OPT_NPM[:common], cmd,
                                      project: self)
@@ -829,12 +774,12 @@ module Squared
 
                 case $1
                 when 'w', 'workspace'
-                  op << ($2.match?(%r{[\\/]}) ? quote_option($1, basepath($2)) : shell_option($1, $2))
+                  op << ($2.match?(%r{[\\/]}) ? quote_option($1, path + $2) : shell_option($1, $2))
                   op.found << opt
                 end
               end
             end
-            op.append?('pack-destination', Dir.pwd)
+            op << quote_option('pack-destination', Dir.pwd) unless op.arg?('pack-destination')
           end
           op.clear
           run(from: :pack)
@@ -846,16 +791,16 @@ module Squared
           if script
             ret = session dependbin, 'run'
             raise_error("#{dependbin} run: given #{target}", hint: from) unless append_any(target, build: true)
-            append_any opts if opts
+            append_any opts
             append_loglevel
-            append_any(args, delim: true) if args
+            append_any(args, delim: true)
             ret
           else
             case target
             when String
               target
             when Hash
-              append_hash(target, target: []).join(' ')
+              append_hash(target).join(' ')
             when Enumerable
               target.to_a.join(' ')
             else
@@ -869,7 +814,7 @@ module Squared
         end
 
         def outdated?
-          dependfile.exist? && !task_pass?('outdated')
+          dependfile.exist?
         end
 
         def update?
@@ -882,32 +827,45 @@ module Squared
 
         def yarn?
           (@pm[:yarn] ||= if rootpath('yarn.lock', ascend: dependext).exist?
-                            yarntype
-                          elsif (ver = read_packagemanager || read_install)
-                            if ver =~ /^yarn(?:@(\d)|$)/
-                              $1 && $1.to_i > 1 ? yarntype : 1
+                            if (rc = rootpath('.yarnrc.yml', ascend: dependext)).exist?
+                              begin
+                                require 'yaml'
+                                doc = YAML.load_file(rc)
+                                doc.nodeLinker == 'node-modules' ? 2 : 3
+                              rescue StandardError => e
+                                log.debug e
+                                3
+                              end
                             else
-                              0
-                            end
-                          else
-                            case @pm[:__]
-                            when 'yarn'
                               1
-                            when 'berry'
-                              yarntype
-                            else
-                              0
                             end
+                          elsif (ver = read_packagemanager || read_install)&.start_with?('yarn')
+                            ver == 'yarn' || ver.include?('@1') ? 1 : 3
+                          else
+                            0
                           end) > 0
         end
 
         def pnpm?
           (@pm[:pnpm] ||= if rootpath('pnpm-lock.yaml', ascend: dependext).exist?
-                            pnpmtype
-                          elsif (ver = read_packagemanager || read_install)
-                            ver.start_with?('pnpm') ? pnpmtype : 0
+                            begin
+                              require 'yaml'
+                              doc = YAML.load_file(basepath('node_modules/.modules.yaml', ascend: dependext))
+                              @pm[:_] = doc['packageManager']
+                              case doc['nodeLinker']
+                              when 'hoisted'
+                                1
+                              when 'pnp'
+                                3
+                              else
+                                4
+                              end
+                            rescue StandardError => e
+                              log.debug e
+                              4
+                            end
                           else
-                            @pm[:__] == 'pnpm' ? pnpmtype : 0
+                            (read_packagemanager || read_install)&.start_with?('pnpm') ? 4 : 0
                           end) > 0
         end
 
@@ -934,125 +892,51 @@ module Squared
           respond_to?(meth) && __send__(meth) ? @pm[prog] : 0
         end
 
-        def dependbin
-          if yarn?
-            'yarn'
-          else
-            pnpm? ? 'pnpm' : 'npm'
-          end
-        end
-
         def version
-          @version ||= read_packagemanager(:version)
+          super || (@version = read_packagemanager(:version))
         end
 
         def packagename
           read_packagemanager :name
         end
 
-        def scripts
-          @scripts ||= read_scripts.to_h
-        end
-
         private
 
         def read_packagemanager(key = nil, version: nil, update: false)
-          if (key ? !@pm.key?(key) : @pm[:_].nil?) || update
+          if @pm[:_].nil? || update
             doc = JSON.parse(dependfile.read)
-            if @pm[:_].nil?
-              @pm[:_] = (val = doc['packageManager']) ? val[0, val.index('+') || val.size] : false
-              @pm[:name] = doc['name']
-              @pm[:scripts] = doc['scripts']
-              @pm[:version] = doc['version']
-              @pm[:private] = doc['private']
-              @pm[:workspaces] = doc['workspaces']
-            end
-            @pm[key] = doc[key.to_s] if key
+            @pm[:_] = (val = doc['packageManager']) ? val[0, val.index('+') || val.size] : false
+            @pm[:name] = doc['name']
+            @pm[:scripts] = doc['scripts']
+            @pm[:version] = doc['version']
+            @pm[:private] = doc['private']
+            @pm[:workspaces] = doc['workspaces']
           end
         rescue StandardError => e
           log.debug e
           @pm[:_] = false
           nil
         else
-          if key
-            @pm[key]
-          elsif (ret = @pm[:_]) && (!version || semgte?(ret[(ret.index('@') + 1)..-1], version))
-            ret
-          end
+          return @pm[key] if key
+
+          !(ret = @pm[:_]) || (version && ret[ret.index('@') + 1..-1] < version) ? nil : ret
         end
 
         def read_install
           return unless (ret = env('NODE_INSTALL'))
 
-          if ret.include?(',')
-            catch :found do
-              split_escape(ret).each do |val|
-                case val
-                when /^yarn/
-                  next if yarntype(exist: true) == 0
-                when /^pnpm/
-                  next if pnpmtype(exist: true) == 0
-                when /^npm/
-                  nil
-                else
-                  next
-                end
-                ret = val
-                throw :found
-              end
-              return
-            end
-          end
-          @pm[:_] ||= ret
+          @pm[:_] ||= ret if ret.include?('@')
           ret
         end
 
-        def yarntype(exist: false)
-          if (rc = rootpath('.yarnrc.yml', ascend: dependext)).exist?
-            require 'yaml'
-            doc = YAML.load_file(rc)
-            doc.nodeLinker == 'node-modules' ? 2 : 3
-          elsif exist && !basepath('yarn.lock').exist?
-            0
-          else
-            1
-          end
-        rescue StandardError => e
-          return 0 if exist
-
-          log.debug e
-          3
-        end
-
-        def pnpmtype(exist: false)
-          require 'yaml'
-          doc = YAML.load_file(basepath('node_modules/.modules.yaml', ascend: dependext))
-          @pm['packageManager'] = doc['packageManager']
-          case doc['nodeLinker']
-          when 'hoisted'
-            1
-          when 'pnp'
-            3
-          else
-            4
-          end
-        rescue StandardError => e
-          if exist
-            %w[pnpm-lock.yaml pnpm-workspace.yaml].any? { |val| basepath(val).exist? } ? 4 : 0
-          else
-            log.debug e
-            4
-          end
-        end
-
         def read_scripts
           ret = read_packagemanager(:scripts)
           ret.is_a?(Hash) ? ret.to_a : []
         end
 
         def append_loglevel(target: @session)
-          level = env('NODE_LOGLEVEL')
-          silent = verbosetype == 0 || level == 'silent'
+          level = env 'NODE_LOGLEVEL'
+          silent = !verbose || level == 'silent'
           return unless silent || level
 
           if yarn?
@@ -1082,11 +966,15 @@ module Squared
           end
         end
 
-        def append_platform(target: @session)
-          %w[cpu os libc].each do |name|
-            next unless (val = option(name))
+        def dryrun?(prefix = dependbin, **)
+          super || !option('dry-run', prefix: prefix).nil?
+        end
 
-            target << basic_option(name, val)
+        def dependbin
+          if yarn?
+            'yarn'
+          else
+            pnpm? ? 'pnpm' : 'npm'
           end
         end
 
@@ -1094,22 +982,14 @@ module Squared
           'package.json' if parent&.has?('outdated', Node.ref)
         end
 
-        def npmname
-          packagename || project
-        end
-
         def npmnotice
           [
-            { pat: /^(npm error )(code|\d+)(.+)$/, styles: color(:bright_cyan), index: 2 },
-            { pat: /^(npm )(error)(.*)$/, styles: color(:bright_red), index: 2 },
-            { pat: /^(npm )(notice)(.*)$/, styles: color(:bright_cyan), index: 2 },
+            { pat: /^(npm error )(code|\d+)(.+)$/, styles: color(:cyan), index: 2 },
+            { pat: /^(npm )(error)(.*)$/, styles: color(:red), index: 2 },
+            { pat: /^(npm )(notice)(.*)$/, styles: color(:cyan), index: 2 },
             { pat: /^(npm )(.+)$/, styles: :bold }
           ]
         end
-
-        def dryrun?(prefix = dependbin, **)
-          super || !option('dry-run', prefix: prefix).nil?
-        end
       end
 
       Application.implement Node