heapscope 0.6.0

data/lib/heapscope/cli/commands/diffing.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module HeapScope
+  class CLI
+    module Commands
+      # Diff / compare / baseline / trends.
+      module Diffing
+        private
+
+        def cmd_diff(argv)
+          return help_exit("diff") if command_wants_help?(argv)
+
+          options = { output: nil, html: nil, top: 15 }
+          OptionParser.new do |opts|
+            opts.banner = "Usage: heapscope diff BEFORE.json AFTER.json [options]"
+            opts.on("-o", "--output PATH", "Write report JSON") { |p| options[:output] = p }
+            opts.on("--html PATH", "Write HTML report") { |p| options[:html] = p }
+            opts.on("--markdown", "Markdown report body") { options[:markdown] = true }
+            opts.on("--markdown-out PATH", "Write Markdown file") { |p| options[:markdown_out] = p }
+            opts.on("--top N", Integer) { |n| options[:top] = n }
+            opts.on("--scorecard-only") { options[:scorecard_only] = true }
+            opts.on("--json") { options[:json] = true }
+            parse_fail_on!(options, opts)
+            # Back-compat alias already covered by --fail-on-high via parse_fail_on!
+            opts.on("-h", "--help") { options[:help] = true }
+          end.parse!(argv)
+          return help_exit("diff") if options[:help]
+
+          before_path, after_path = argv.shift(2)
+          raise ArgumentError, "diff requires BEFORE.json AFTER.json" unless before_path && after_path
+
+          report = HeapScope.compare(before_path, after_path)
+          if options[:top] && report.diff
+            options[:table_text] = Tables.class_growth(report.diff, limit: options[:top],
+                                                                    format: options[:markdown] ? :markdown : :ascii)
+          end
+
+          if json_mode? || options[:json]
+            emit_json(report.to_h)
+          elsif options[:scorecard_only]
+            say report.scorecard.to_text
+          else
+            unless quiet?
+              say report.scorecard.to_text
+              say
+              say(options[:table_text] || report.table)
+              say
+              puts(options[:markdown] ? report.to_markdown : report.to_text)
+            end
+          end
+
+          write_outputs(report, options)
+          exit_for_findings(report, fail_on: options[:fail_on])
+        end
+
+        def cmd_baseline(argv)
+          return help_exit("baseline") if command_wants_help?(argv)
+
+          sub = argv.shift
+          case sub
+          when "create"
+            options = { output: "baseline.json" }
+            OptionParser.new do |opts|
+              opts.on("-o", "--output PATH") { |p| options[:output] = p }
+              opts.on("-h", "--help") { options[:help] = true }
+            end.parse!(argv)
+            return help_exit("baseline") if options[:help]
+
+            input = argv.shift or raise ArgumentError, "baseline create requires REPORT.json"
+            Baseline.create(input, options[:output])
+            say "Created baseline #{options[:output]}"
+            EXIT_OK
+          when nil, "-h", "--help"
+            help_exit("baseline")
+          else
+            say_err "Usage: heapscope baseline create REPORT.json -o baseline.json"
+            EXIT_INVALID
+          end
+        end
+
+        def cmd_compare(argv)
+          return help_exit("compare") if command_wants_help?(argv)
+
+          options = { threshold: 0.5 }
+          OptionParser.new do |opts|
+            opts.banner = "Usage: heapscope compare BASELINE.json CURRENT.json"
+            opts.on("--threshold F", Float) { |f| options[:threshold] = f }
+            opts.on("--json") { options[:json] = true }
+            opts.on("-h", "--help") { options[:help] = true }
+          end.parse!(argv)
+          return help_exit("compare") if options[:help]
+
+          baseline, current = argv.shift(2)
+          raise ArgumentError, "compare requires BASELINE.json CURRENT.json" unless baseline && current
+
+          result = Baseline.compare(baseline, current, threshold: options[:threshold])
+          if json_mode? || options[:json]
+            emit_json(
+              result.merge(
+                findings: result[:findings].map { |f| f.respond_to?(:to_h) ? f.to_h : f }
+              )
+            )
+          else
+            puts Color.bold("MEMORY COMPARISON", enabled: color?)
+            puts "Retained objects: baseline=#{result[:baseline_retained_objects]} current=#{result[:current_retained_objects]}"
+            puts "Change: #{(result[:object_change_ratio] * 100).round(1)}%"
+            puts "Retained bytes: baseline=#{result[:baseline_retained_bytes]} current=#{result[:current_retained_bytes]}"
+            label = result[:result]
+            colored =
+              if result[:regression]
+                Color.err(label, enabled: color?)
+              else
+                Color.ok(label, enabled: color?)
+              end
+            puts "Result: #{colored}"
+            result[:findings].each { |f| puts "#{f.code}: #{f.title}" }
+          end
+          result[:regression] ? EXIT_REGRESSION : EXIT_OK
+        end
+
+        def cmd_trends(argv)
+          return help_exit("trends") if command_wants_help?(argv)
+
+          options = {}
+          OptionParser.new do |opts|
+            opts.on("--json") { options[:json] = true }
+            opts.on("-h", "--help") { options[:help] = true }
+          end.parse!(argv)
+          return help_exit("trends") if options[:help]
+
+          path = argv.shift or raise ArgumentError, "trends REPORT.json required"
+          report = load_report!(path)
+          timeline = report.metadata[:timeline] || report.metadata["timeline"]
+          if timeline.nil? || timeline.empty?
+            say_err "No timeline in report. Run: heapscope monitor ..."
+            return EXIT_INVALID
+          end
+          if json_mode? || options[:json]
+            emit_json(timeline: timeline)
+          else
+            puts "TIME                 RSS          LIVE         TOP"
+            timeline.each do |row|
+              puts format(
+                "%-20s %-12s %-12s %s",
+                row[:time] || row["time"],
+                row[:rss_bytes] || row["rss_bytes"],
+                row[:live_slots] || row["live_slots"],
+                row[:top_class] || row["top_class"]
+              )
+            end
+          end
+          EXIT_OK
+        end
+      end
+    end
+  end
+end

data/lib/heapscope/cli/commands/meta.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+module HeapScope
+  class CLI
+    module Commands
+      # Doctor, about, env, codes, explain, completion, config, sessions, etc.
+      module Meta
+        private
+
+        def cmd_capabilities(argv)
+          options = {}
+          OptionParser.new do |opts|
+            opts.on("--json") { options[:json] = true }
+            opts.on("-h", "--help") { options[:help] = true }
+          end.parse!(argv)
+          return help_exit("capabilities") if options[:help]
+
+          caps = HeapScope.capabilities
+          if json_mode? || options[:json]
+            emit_json(caps.to_h)
+          else
+            puts caps
+          end
+          EXIT_OK
+        end
+
+        def cmd_doctor(argv)
+          return help_exit("doctor") if command_wants_help?(argv)
+
+          options = { fix_path: "heapscope.yml" }
+          OptionParser.new do |opts|
+            opts.on("--json") { options[:json] = true }
+            opts.on("--fix", "Write a starter heapscope.yml (local only)") { options[:fix] = true }
+            opts.on("--config-out PATH", "Output path for --fix (default heapscope.yml)") { |p| options[:fix_path] = p }
+            opts.on("--force", "Overwrite existing config when using --fix") { options[:force] = true }
+            opts.on("-h", "--help") { options[:help] = true }
+          end.parse!(argv)
+          return help_exit("doctor") if options[:help]
+
+          if options[:fix]
+            path = ConfigLoader.write_starter!(options[:fix_path], force: options[:force])
+            say "Wrote starter config to #{path}"
+            HeapScope.load_config!(path)
+          end
+
+          if json_mode? || options[:json]
+            emit_json(HeapScope.doctor.merge(fragmentation: doctor_fragmentation, config_path: options[:fix] ? options[:fix_path] : nil))
+            return EXIT_OK
+          end
+
+          puts Color.bold(Branding.compact_banner, enabled: color?)
+          puts "HeapScope doctor"
+          caps = HeapScope.capabilities
+          puts "Ruby #{RUBY_VERSION} (#{RUBY_ENGINE}) on #{RUBY_PLATFORM}"
+          puts
+          puts caps
+          puts
+          puts "Config mode: #{HeapScope.config.mode}"
+          puts "Noise patterns: #{HeapScope.config.ignore_patterns.size}"
+          frag = doctor_fragmentation
+          puts "Fragmentation indicator: #{frag[:status]} (#{frag[:note]})"
+          puts "RSS tracking: #{caps.rss_tracking}"
+          puts "Allocation tracing: #{caps.allocation_tracing}"
+          puts "Reachable objects: #{caps.reachable_objects}"
+          puts "Budget presets: #{Budget.presets.join(', ')}"
+          puts
+          Branding.funding_lines.each { |line| puts line }
+          puts
+          puts "Privacy: local-only, no telemetry, no value dumps by default."
+          puts "Tip: heapscope doctor --fix   # write starter heapscope.yml"
+          EXIT_OK
+        end
+
+        def doctor_fragmentation
+          Fragmentation.assess(HeapScope.snapshot(mode: :lightweight))
+        rescue StandardError => e
+          { status: :error, note: e.message }
+        end
+
+        def cmd_overhead(argv)
+          return help_exit("overhead") if command_wants_help?(argv)
+
+          options = { mode: :lightweight, runs: 3 }
+          OptionParser.new do |opts|
+            opts.on("--mode MODE", %w[lightweight standard deep]) { |m| options[:mode] = m.to_sym }
+            opts.on("--runs N", Integer) { |n| options[:runs] = n }
+            opts.on("--json") { options[:json] = true }
+            opts.on("-h", "--help") { options[:help] = true }
+          end.parse!(argv)
+          return help_exit("overhead") if options[:help]
+
+          result = Overhead.measure_snapshot(mode: options[:mode], runs: options[:runs])
+          if json_mode? || options[:json]
+            emit_json(result)
+          else
+            puts "OVERHEAD mode=#{result[:mode]} avg=#{result[:avg_seconds]}s"
+            result[:runs].each_with_index do |run, i|
+              puts "  run #{i + 1}: #{run[:seconds].round(4)}s (#{run[:classes]} classes)"
+            end
+            puts result[:note]
+          end
+          EXIT_OK
+        end
+
+        def cmd_config(argv)
+          return help_exit("config") if command_wants_help?(argv)
+
+          path = argv.shift or raise ArgumentError, "config PATH required"
+          HeapScope.load_config!(path)
+          say "Loaded config from #{path}"
+          say "mode=#{HeapScope.config.mode} track_allocations=#{HeapScope.config.track_allocations}"
+          EXIT_OK
+        end
+
+        def cmd_codes(_argv)
+          puts Catalog.to_text
+          EXIT_OK
+        end
+
+        def cmd_explain(argv)
+          return help_exit("explain") if command_wants_help?(argv)
+
+          code = argv.shift or raise ArgumentError, "explain CODE required (e.g. HS001)"
+          puts Catalog.explain(code)
+          EXIT_OK
+        end
+
+        def cmd_sessions(_argv)
+          sessions = Session.list
+          if sessions.empty?
+            say "No sessions in .heapscope/sessions"
+            return EXIT_OK
+          end
+          sessions.each do |s|
+            puts "#{s[:name]}  id=#{s[:id]}  reports=#{Array(s[:reports]).size}  created=#{s[:created_at]}"
+          end
+          EXIT_OK
+        end
+
+        def cmd_history(argv)
+          return help_exit("history") if command_wants_help?(argv)
+
+          options = { limit: 10 }
+          OptionParser.new do |opts|
+            opts.on("--limit N", Integer) { |n| options[:limit] = n }
+            opts.on("-h", "--help") { options[:help] = true }
+          end.parse!(argv)
+          return help_exit("history") if options[:help]
+
+          sessions = Session.list
+          entries = sessions.flat_map { |s| Array(s[:reports]).map { |r| r.merge(session: s[:name]) } }
+                            .sort_by { |e| e[:at].to_s }
+                            .reverse
+                            .first(options[:limit])
+          if entries.empty?
+            say "No history yet. Use HeapScope.session('name') in Ruby."
+            return EXIT_OK
+          end
+          entries.each do |e|
+            puts "#{e[:at]}  #{e[:session]}/#{e[:label]}  healthy=#{e[:healthy]}  #{e[:path]}"
+          end
+          EXIT_OK
+        end
+
+        def cmd_about(argv)
+          options = {}
+          OptionParser.new do |opts|
+            opts.on("--json") { options[:json] = true }
+            opts.on("-h", "--help") { options[:help] = true }
+          end.parse!(argv)
+          return help_exit("about") if options[:help]
+
+          if json_mode? || options[:json]
+            emit_json(Branding.to_h)
+          else
+            puts Branding.about_text
+          end
+          EXIT_OK
+        end
+
+        def cmd_man(_argv)
+          puts Branding.banner
+          puts
+          puts Branding.about_text
+          puts
+          puts "Examples:"
+          puts "  heapscope doctor"
+          puts "  heapscope snapshot --mode standard -o before.json"
+          puts "  heapscope diff before.json after.json --html out.html --fail-on-medium"
+          puts "  heapscope probe --eval '1000.times { Object.new }'"
+          puts "  heapscope explain HS001"
+          puts "  heapscope self-test"
+          puts "  heapscope pack report.json -o ./pack"
+          puts
+          puts "Exit codes: 0 ok · 1 regression · 2 invalid · 3 capability"
+          puts "Privacy: local-only — no telemetry, no network from the gem."
+          EXIT_OK
+        end
+
+        def cmd_env(argv)
+          options = {}
+          OptionParser.new do |opts|
+            opts.on("--json") { options[:json] = true }
+            opts.on("-h", "--help") { options[:help] = true }
+          end.parse!(argv)
+          return help_exit("env") if options[:help]
+
+          keys = %w[
+            RUBY_VERSION RUBYOPT RUBYLIB GEM_HOME GEM_PATH BUNDLE_GEMFILE
+            HEAPSCOPE_CONFIG HEAPSCOPE_MODE HEAPSCOPE_QUIET
+            NO_COLOR TERM FORCE_COLOR
+          ]
+          data = {
+            ruby_version: RUBY_VERSION,
+            ruby_engine: RUBY_ENGINE,
+            ruby_platform: RUBY_PLATFORM,
+            heapscope_version: VERSION,
+            env: keys.to_h { |k| [k, ENV.fetch(k, nil)] }
+          }
+          if json_mode? || options[:json]
+            emit_json(data)
+          else
+            puts Color.bold(Branding.compact_banner, enabled: color?)
+            puts "RUBY_VERSION=#{RUBY_VERSION}  ENGINE=#{RUBY_ENGINE}  PLATFORM=#{RUBY_PLATFORM}"
+            puts "HeapScope=#{VERSION}"
+            puts
+            data[:env].each do |k, v|
+              puts format("%-18s %s", k, v.nil? ? "(unset)" : v)
+            end
+          end
+          EXIT_OK
+        end
+
+        def cmd_completion(argv)
+          return help_exit("completion") if command_wants_help?(argv)
+
+          shell = argv.shift or raise ArgumentError, "completion requires bash|zsh|powershell"
+          puts Completion.generate(shell)
+          EXIT_OK
+        end
+      end
+    end
+  end
+end

data/lib/heapscope/cli/commands/reporting.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module HeapScope
+  class CLI
+    module Commands
+      # Report rendering, pack/export, findings, scorecard, table, open/html.
+      module Reporting
+        private
+
+        def cmd_report(argv)
+          return help_exit("report") if command_wants_help?(argv)
+
+          options = { format: "text", output: nil }
+          OptionParser.new do |opts|
+            opts.banner = "Usage: heapscope report REPORT.json [options]"
+            opts.on("--format FMT", %w[text html json markdown md]) { |f| options[:format] = f }
+            opts.on("-o", "--output PATH") { |p| options[:output] = p }
+            opts.on("-h", "--help") { options[:help] = true }
+          end.parse!(argv)
+          return help_exit("report") if options[:help]
+
+          path = argv.shift or raise ArgumentError, "report path required"
+          report = load_report!(path)
+          format = json_mode? ? "json" : options[:format]
+          content =
+            case format
+            when "html" then Report::HTML.render(report)
+            when "json" then report.to_json
+            when "markdown", "md" then report.to_markdown
+            else report.to_text
+            end
+          if options[:output]
+            File.write(options[:output], content)
+            say "Wrote #{options[:output]}"
+          else
+            puts content
+          end
+          EXIT_OK
+        end
+
+        def cmd_pack(argv)
+          return help_exit("pack") if command_wants_help?(argv)
+
+          options = { output: "heapscope-pack", label: "heapscope-report" }
+          OptionParser.new do |opts|
+            opts.banner = "Usage: heapscope pack REPORT.json [options]"
+            opts.on("-o", "--output DIR", "Output directory") { |p| options[:output] = p }
+            opts.on("--label NAME", "File basename") { |n| options[:label] = n }
+            opts.on("--json") { options[:json] = true }
+            opts.on("-h", "--help") { options[:help] = true }
+          end.parse!(argv)
+          return help_exit("pack") if options[:help]
+
+          path = argv.shift or raise ArgumentError, "pack REPORT.json required"
+          report = load_report!(path)
+          result = Pack.export(report, options[:output], label: options[:label])
+          if json_mode? || options[:json]
+            emit_json(result)
+          else
+            say "Wrote local pack to #{result[:dir]}"
+            say "  #{result[:json]}"
+            say "  #{result[:html]}"
+            say "  #{result[:markdown]}"
+          end
+          EXIT_OK
+        end
+
+        def cmd_export(argv)
+          cmd_pack(argv)
+        end
+
+        def cmd_suggest(argv)
+          return help_exit("suggest") if command_wants_help?(argv)
+
+          options = {}
+          OptionParser.new do |opts|
+            opts.on("--json") { options[:json] = true }
+            opts.on("--ignores-only") { options[:ignores_only] = true }
+            opts.on("-h", "--help") { options[:help] = true }
+          end.parse!(argv)
+          return help_exit("suggest") if options[:help]
+
+          path = argv.shift or raise ArgumentError, "suggest REPORT.json required"
+          report = load_report!(path)
+          if json_mode? || options[:json]
+            payload = {
+              next_steps: Suggest.next_steps(report),
+              ignore_patterns: Suggest.ignore_patterns(report)
+            }
+            payload.delete(:next_steps) if options[:ignores_only]
+            emit_json(payload)
+          elsif options[:ignores_only]
+            patterns = Suggest.ignore_patterns(report)
+            if patterns.empty?
+              say "No ignore suggestions."
+            else
+              patterns.each { |p| puts p }
+            end
+          else
+            puts Suggest.report_text(report)
+          end
+          EXIT_OK
+        end
+
+        def cmd_ignore_suggest(argv)
+          cmd_suggest(argv)
+        end
+
+        def cmd_findings(argv)
+          return help_exit("findings") if command_wants_help?(argv)
+
+          options = {}
+          OptionParser.new do |opts|
+            opts.on("--severity LEVEL", %w[low medium high]) { |s| options[:severity] = s.to_sym }
+            opts.on("--code CODE") { |c| options[:code] = Catalog.normalize_code(c) }
+            opts.on("--json") { options[:json] = true }
+            opts.on("-h", "--help") { options[:help] = true }
+          end.parse!(argv)
+          return help_exit("findings") if options[:help]
+
+          path = argv.shift or raise ArgumentError, "findings REPORT.json required"
+          report = load_report!(path)
+          list = Findings.rank_and_dedupe(report.findings)
+          list = list.select { |f| f.severity.to_sym == options[:severity] } if options[:severity]
+          list = list.select { |f| f.code == options[:code] } if options[:code]
+
+          if json_mode? || options[:json]
+            emit_json(findings: list.map(&:to_h), count: list.size)
+          elsif list.empty?
+            say "No findings matched."
+          else
+            puts Tables.findings(
+              Report.new(findings: list, summary: report.summary, metadata: report.metadata),
+              format: :ascii
+            )
+            list.each do |f|
+              sev = Color.severity(f.severity, enabled: color?)
+              say "#{f.code} [#{sev}] #{f.title}#{f.subject ? " (#{f.subject})" : ""}"
+            end
+          end
+          EXIT_OK
+        end
+
+        def cmd_scorecard(argv)
+          return help_exit("scorecard") if command_wants_help?(argv)
+
+          options = { title: "HeapScope" }
+          OptionParser.new do |opts|
+            opts.on("--title NAME") { |t| options[:title] = t }
+            opts.on("--json") { options[:json] = true }
+            opts.on("-h", "--help") { options[:help] = true }
+          end.parse!(argv)
+          return help_exit("scorecard") if options[:help]
+
+          path = argv.shift or raise ArgumentError, "scorecard REPORT.json required"
+          report = load_report!(path)
+          card = report.scorecard(title: options[:title])
+          if json_mode? || options[:json]
+            emit_json(card.to_h)
+          else
+            puts card.to_text
+          end
+          EXIT_OK
+        end
+
+        def cmd_table(argv)
+          return help_exit("table") if command_wants_help?(argv)
+
+          options = { top: 15 }
+          OptionParser.new do |opts|
+            opts.on("--markdown") { options[:markdown] = true }
+            opts.on("--top N", Integer) { |n| options[:top] = n }
+            opts.on("-h", "--help") { options[:help] = true }
+          end.parse!(argv)
+          return help_exit("table") if options[:help]
+
+          path = argv.shift or raise ArgumentError, "table REPORT.json required"
+          report = load_report!(path)
+          raise ArgumentError, "report has no diff/table data" unless report.diff
+
+          puts Tables.class_growth(
+            report.diff,
+            limit: options[:top],
+            format: options[:markdown] ? :markdown : :ascii
+          )
+          EXIT_OK
+        end
+
+        def cmd_open(argv)
+          return help_exit("open") if command_wants_help?(argv)
+
+          options = {}
+          OptionParser.new do |opts|
+            opts.on("-o", "--output PATH") { |p| options[:output] = p }
+            opts.on("-h", "--help") { options[:help] = true }
+          end.parse!(argv)
+          return help_exit("open") if options[:help]
+
+          path = argv.shift or raise ArgumentError, "open REPORT.json required"
+          report = load_report!(path)
+          out = options[:output] || "#{path.sub(/\.json\z/i, "")}.html"
+          out = "#{path}.html" if out == path
+          report.save_html(out)
+          if json_mode?
+            emit_json(html: out)
+          else
+            puts out
+          end
+          EXIT_OK
+        end
+
+        def cmd_html(argv)
+          cmd_open(argv)
+        end
+
+        def cmd_validate(argv)
+          return help_exit("validate") if command_wants_help?(argv)
+
+          path = argv.shift or raise ArgumentError, "validate REPORT.json required"
+          data = load_json_path!(path)
+          Schema.validate!(data)
+          say "OK  schema_version=#{data[:schema_version]} heapscope=#{data[:heapscope_version]}"
+          EXIT_OK
+        end
+      end
+    end
+  end
+end

data/lib/heapscope/cli/completion.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module HeapScope
+  class CLI
+    # Shell completion script generators (local; no network).
+    module Completion
+      NAMES = Help::COMMANDS.keys.freeze
+
+      module_function
+
+      def generate(shell)
+        case shell.to_s.downcase
+        when "bash" then bash
+        when "zsh" then zsh
+        when "powershell", "pwsh" then powershell
+        else
+          raise ArgumentError, "unsupported shell: #{shell} (bash|zsh|powershell)"
+        end
+      end
+
+      def bash
+        list = NAMES.join(" ")
+        <<~BASH
+          # heapscope bash completion — eval "$(heapscope completion bash)"
+          _heapscope() {
+            local cur="${COMP_WORDS[COMP_CWORD]}"
+            if [[ ${COMP_CWORD} -eq 1 ]]; then
+              COMPREPLY=( $(compgen -W "#{list}" -- "$cur") )
+            else
+              COMPREPLY=( $(compgen -f -- "$cur") )
+            fi
+          }
+          complete -F _heapscope heapscope
+        BASH
+      end
+
+      def zsh
+        descriptions = NAMES.map do |n|
+          desc = Help::COMMANDS[n].to_s.tr("'", " ")
+          "'#{n}:#{desc}'"
+        end.join(" ")
+        <<~ZSH
+          # heapscope zsh completion — eval "$(heapscope completion zsh)"
+          _heapscope() {
+            local -a cmds
+            cmds=(#{descriptions})
+            if (( CURRENT == 2 )); then
+              _describe 'command' cmds
+            else
+              _files
+            fi
+          }
+          compdef _heapscope heapscope
+        ZSH
+      end
+
+      def powershell
+        list = NAMES.map { |n| "'#{n}'" }.join(", ")
+        <<~PS
+          # heapscope PowerShell completion — heapscope completion powershell | Out-String | Invoke-Expression
+          Register-ArgumentCompleter -CommandName heapscope -ScriptBlock {
+            param($wordToComplete, $commandAst, $cursorPosition)
+            $commands = @(#{list})
+            $commands | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+              [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+            }
+          }
+        PS
+      end
+    end
+  end
+end