shared_tools 0.4.4 → 0.6.0

data/lib/shared_tools/tools/parse_ruby_tool.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "pathname"
+require_relative "../../shared_tools"
+require_relative "../ruby_outline"
+
+module SharedTools
+  module Tools
+    # Produces a structural outline of a Ruby file (classes, modules,
+    # methods, constants) with line numbers, or finds where a name is
+    # defined. In-process via Ripper/Prism — it parses, never executes, the
+    # code. Read-only.
+    #
+    # @example
+    #   tool = SharedTools::Tools::ParseRubyTool.new
+    #   tool.execute(path: "./lib/foo.rb")
+    #   tool.execute(path: "./lib/foo.rb", query: "initialize")
+    #   tool.execute(path: "./lib/foo.rb", kind: "method")
+    class ParseRubyTool < ::RubyLLM::Tool
+      KINDS = %w[class module method constant].freeze
+      MAX_BYTES = 5 * 1024 * 1024
+
+      def self.name = 'parse_ruby'
+
+      description "Outline a Ruby file's structure (classes, modules, methods, constants with line " \
+                  "numbers), or locate definitions. Give a query to find definitions whose name " \
+                  "matches, and/or a kind to filter. Parses in-process; does not run the code."
+
+      parameters do
+        string :path,  description: "Ruby file to outline."
+        string :query, description: "Only show definitions whose (qualified) name matches this, case-insensitive. Optional.", required: false
+        string :kind,  description: "Filter to a kind: class, module, method, or constant. Optional.", required: false
+      end
+
+      # @param logger [Logger] optional logger
+      def initialize(logger: nil)
+        @logger = logger || RubyLLM.logger
+      end
+
+      # @param path [String]
+      # @param query [String, nil]
+      # @param kind [String, nil]
+      #
+      # @return [String, Hash]
+      def execute(path:, query: nil, kind: nil)
+        @logger.info("#{self.class.name}#execute path=#{path.inspect} query=#{query.inspect} kind=#{kind.inspect}")
+
+        k = kind.to_s.strip.downcase
+        k = nil if k.empty?
+        return { error: "unknown kind: #{k} (use #{KINDS.join(', ')})" } if k && !KINDS.include?(k)
+
+        return { error: "file not found: #{path}" } unless File.exist?(path)
+        return { error: "not a file: #{path}" } unless File.file?(path)
+        return { error: "file too large (> #{MAX_BYTES} bytes)" } if File.size(path) > MAX_BYTES
+
+        entries = SharedTools::RubyOutline.extract(File.read(path).scrub)
+        return "no definitions found in #{path}" if entries.empty?
+
+        render(entries, path, query, k)
+      rescue SharedTools::RubyOutline::ParseError => e
+        @logger.error("#{self.class.name}: #{e.message} in #{path}")
+        { error: "#{e.message} in #{path}" }
+      rescue => e
+        @logger.error("#{self.class.name} failed: #{e.message}")
+        { error: e.message }
+      end
+
+      private
+
+      def render(entries, path, query, kind)
+        if query || kind
+          flat_list(entries, path, query, kind)
+        else
+          "Outline of #{path}:\n#{tree(entries)}"
+        end
+      end
+
+      def tree(entries)
+        entries.map { |e| "#{'  ' * e.depth}#{label(e)} (L#{e.line})" }.join("\n")
+      end
+
+      def flat_list(entries, path, query, kind)
+        pairs = qualify(entries)
+        pairs = pairs.select { |e, _| e.kind.to_s == kind } if kind
+        if query
+          q = query.downcase
+          pairs = pairs.select { |e, qn| qn.downcase.include?(q) || e.name.downcase.include?(q) }
+        end
+        return "no matching definitions in #{path}" if pairs.empty?
+
+        desc = ["definitions", ("matching #{query.inspect}" if query), ("of kind #{kind}" if kind)].compact.join(" ")
+        header = "#{pairs.size} #{desc} in #{path}:"
+        "#{header}\n#{pairs.map { |e, qn| "#{qn} (L#{e.line}) [#{e.kind}]" }.join("\n")}"
+      end
+
+      # Pair each entry with its fully-qualified name using the depth stack.
+      def qualify(entries)
+        namespace = []
+        entries.map do |entry|
+          namespace = namespace.first(entry.depth)
+          ns = namespace.compact
+          qualified =
+            case entry.kind
+            when :class, :module, :singleton_class
+              full = (ns + [entry.name]).join("::")
+              namespace[entry.depth] = entry.name
+              full
+            when :method
+              ns.empty? ? entry.name : "#{ns.join('::')}##{entry.name}"
+            else # constant
+              ns.empty? ? entry.name : "#{ns.join('::')}::#{entry.name}"
+            end
+          [entry, qualified]
+        end
+      end
+
+      def label(entry)
+        case entry.kind
+        when :class, :singleton_class then "class #{entry.name}"
+        when :module then "module #{entry.name}"
+        when :method then "def #{entry.name}"
+        else entry.name
+        end
+      end
+    end
+  end
+end

data/lib/shared_tools/tools/process_kill_tool.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "../../shared_tools"
+require_relative "../process_registry"
+
+module SharedTools
+  module Tools
+    # Stops a background process: SIGTERM to its process group, escalating
+    # to SIGKILL if it doesn't exit, then returns any final output. Always
+    # available, with no authorization prompt, so a runaway process can
+    # always be stopped. Removes the process from the registry.
+    #
+    # @example
+    #   tool = SharedTools::Tools::ProcessKillTool.new
+    #   tool.execute(id: "proc_1")
+    class ProcessKillTool < ::RubyLLM::Tool
+      def self.name = 'process_kill'
+
+      description "Stop a background process (started with process_start) and return any final " \
+                  "output. Terminates the whole process group, escalating to SIGKILL if needed."
+
+      parameters do
+        string :id, description: "The process id to kill (e.g. 'proc_1')."
+      end
+
+      # @param logger [Logger] optional logger
+      def initialize(logger: nil)
+        @logger = logger || RubyLLM.logger
+      end
+
+      # @param id [String]
+      #
+      # @return [String, Hash]
+      def execute(id:)
+        @logger.info("#{self.class.name}#execute id=#{id.inspect}")
+
+        proc = SharedTools::ProcessRegistry.get(id)
+        return { error: "no such process: #{id}" } unless proc
+
+        was_running = proc.running?
+        proc.kill
+        final = proc.read_new
+        SharedTools::ProcessRegistry.delete(id)
+
+        body = +"#{id} #{was_running ? 'terminated' : 'was already exited'}"
+        body << " (exit #{proc.exit_code})" if proc.exit_code
+        unless final[:out].empty? && final[:err].empty?
+          body << "\n--- final stdout ---\n#{final[:out]}" unless final[:out].empty?
+          body << "\n--- final stderr ---\n#{final[:err]}" unless final[:err].empty?
+        end
+        body
+      end
+    end
+  end
+end

data/lib/shared_tools/tools/process_list_tool.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../../shared_tools"
+require_relative "../process_registry"
+
+module SharedTools
+  module Tools
+    # Lists the background processes started this run (with ProcessStartTool):
+    # id, status, pid, age, and command — so a caller can rediscover ids and
+    # see what's still running. Read-only.
+    #
+    # @example
+    #   tool = SharedTools::Tools::ProcessListTool.new
+    #   tool.execute
+    class ProcessListTool < ::RubyLLM::Tool
+      def self.name = 'process_list'
+
+      description "List background processes (started with process_start): id, status, pid, age, and " \
+                  "command. Read-only."
+
+      # @param logger [Logger] optional logger
+      def initialize(logger: nil)
+        @logger = logger || RubyLLM.logger
+      end
+
+      # @return [String]
+      def execute
+        @logger.info("#{self.class.name}#execute")
+
+        procs = SharedTools::ProcessRegistry.all
+        return "no background processes" if procs.empty?
+
+        lines = procs.map do |proc|
+          status = proc.status == :exited ? "exited(#{proc.exit_code})" : "running"
+          "#{proc.id}  #{status.ljust(12)}  pid=#{proc.pid}  age=#{proc.age.round}s  #{proc.name}  #{proc.argv.inspect}"
+        end
+        (["#{procs.size} process#{procs.size == 1 ? '' : 'es'}:"] + lines).join("\n")
+      end
+    end
+  end
+end

data/lib/shared_tools/tools/process_output_tool.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "../../shared_tools"
+require_relative "../process_registry"
+
+module SharedTools
+  module Tools
+    # Returns the output a background process has produced since the last
+    # read, plus its current status (running, or exited with a code). Reads
+    # are incremental, so polling in a loop streams the process's output
+    # without repeats. Read-only.
+    #
+    # @example
+    #   tool = SharedTools::Tools::ProcessOutputTool.new
+    #   tool.execute(id: "proc_1")
+    class ProcessOutputTool < ::RubyLLM::Tool
+      def self.name = 'process_output'
+
+      description "Read new stdout/stderr from a background process (started with process_start) " \
+                  "since the last read, along with its status and exit code if it has finished. Poll " \
+                  "this to follow a process's output."
+
+      parameters do
+        string :id, description: "The process id returned by process_start (e.g. 'proc_1')."
+      end
+
+      # @param logger [Logger] optional logger
+      def initialize(logger: nil)
+        @logger = logger || RubyLLM.logger
+      end
+
+      # @param id [String]
+      #
+      # @return [String, Hash]
+      def execute(id:)
+        @logger.info("#{self.class.name}#execute id=#{id.inspect}")
+
+        proc = SharedTools::ProcessRegistry.get(id)
+        return { error: "no such process: #{id}" } unless proc
+
+        data = proc.read_new
+        format_output(proc, data)
+      end
+
+      private
+
+      def format_output(proc, data)
+        body = +"#{proc.id} (#{proc.name}): #{proc.status}"
+        body << " (exit #{proc.exit_code})" if proc.status == :exited && proc.exit_code
+        body << "\n"
+
+        if data[:out].empty? && data[:err].empty?
+          body << "(no new output)"
+          return body
+        end
+
+        unless data[:out].empty?
+          body << "\n--- stdout#{data[:out_dropped] ? ' (earlier output dropped)' : ''} ---\n"
+          body << data[:out]
+        end
+        unless data[:err].empty?
+          body << "\n--- stderr#{data[:err_dropped] ? ' (earlier output dropped)' : ''} ---\n"
+          body << data[:err]
+        end
+        body
+      end
+    end
+  end
+end

data/lib/shared_tools/tools/python_tests_tool.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative "../../shared_tools"
+require_relative "toolchain_helpers"
+
+module SharedTools
+  module Tools
+    # Runs a Python project's tests (pytest or unittest) from root and
+    # returns the output with a pass/fail headline. A failing suite is a
+    # normal result, not a tool error. Runs in the project environment, so a
+    # virtualenv/installed deps resolve as they would in a shell. Requires
+    # user authorization (see SharedTools.execute?) since it executes an
+    # external command.
+    #
+    # @example
+    #   tool = SharedTools::Tools::PythonTestsTool.new(root: "./my-project")
+    #   tool.execute
+    #   tool.execute(path: "tests/test_models.py", framework: "unittest")
+    class PythonTestsTool < ::RubyLLM::Tool
+      include ToolchainHelpers
+
+      FRAMEWORKS = %w[pytest unittest].freeze
+      DEFAULT_TIMEOUT = 180
+
+      def self.name = 'python_tests'
+
+      description "Run a Python project's test suite from root and report results. Uses pytest by " \
+                  "default, or unittest (python -m unittest discover) when framework is unittest. " \
+                  "Optionally scope to a path."
+
+      parameters do
+        string :path,      description: "Limit the run to this test file or directory, relative to root. Optional.", required: false
+        string :framework, description: "pytest (default) or unittest.", required: false
+      end
+
+      # @param root [String] optional, defaults to the current directory
+      # @param logger [Logger] optional logger
+      def initialize(root: nil, logger: nil)
+        @root = root || Dir.pwd
+        @logger = logger || RubyLLM.logger
+      end
+
+      # @param path [String, nil]
+      # @param framework [String]
+      #
+      # @return [String, Hash]
+      def execute(path: nil, framework: "pytest")
+        @logger.info("#{self.class.name}#execute path=#{path.inspect} framework=#{framework}")
+
+        fw = framework.to_s.strip.downcase
+        fw = "pytest" if fw.empty?
+        return { error: "unknown framework: #{fw} (use #{FRAMEWORKS.join(', ')})" } unless FRAMEWORKS.include?(fw)
+
+        rel = jail_relative(path)
+
+        allowed = SharedTools.execute?(tool: self.class.to_s, stuff: "Run #{fw} tests#{rel ? " (#{rel})" : ''}")
+        unless allowed
+          @logger.warn("User declined to run tests")
+          return { error: "User declined to run tests" }
+        end
+
+        out, err, status = run_in_project(args_for(fw, rel), use_bundle: false, timeout: DEFAULT_TIMEOUT)
+        toolchain_output(out, err, status,
+                         pass_label: summarize(out, err, "TESTS PASSED"),
+                         fail_label: summarize(out, err, "TESTS FAILED"),
+                         timeout: DEFAULT_TIMEOUT)
+      rescue SecurityError => e
+        @logger.error("#{self.class.name} path denied: #{e.message}")
+        { error: e.message }
+      rescue CommandMissing => e
+        @logger.error("#{self.class.name}: #{e.message} is not available")
+        { error: "#{e.message} is not available (is it installed in the project env?)" }
+      end
+
+      private
+
+      def args_for(framework, rel)
+        if framework == "unittest"
+          args = ["python3", "-m", "unittest", "discover"]
+          args += ["-s", rel] if rel
+        else
+          args = ["pytest"]
+          args << rel if rel
+        end
+        args
+      end
+
+      # Surface pytest's or unittest's summary in the headline.
+      def summarize(out, err, label)
+        text = "#{out}\n#{err}"
+        counts = %w[passed failed error skipped].filter_map do |word|
+          m = text.match(/(\d+) #{word}/)
+          "#{m[1]} #{word}" if m
+        end
+        return "#{label} (#{counts.join(', ')})" unless counts.empty?
+
+        if (m = text.match(/Ran (\d+) tests?.*?(OK|FAILED)/m))
+          return "#{label} (ran #{m[1]}, #{m[2]})"
+        end
+
+        label
+      end
+    end
+  end
+end

data/lib/shared_tools/tools/replace_in_files_tool.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require_relative "../../shared_tools"
+
+module SharedTools
+  module Tools
+    # Find-and-replace across the files in root that match a glob. Literal
+    # by default; set regex: true for a pattern (with backreferences in the
+    # replacement). Binary files and ignored directories are skipped, the
+    # pattern runs under a ReDoS timeout, and every path is confined to
+    # root. Use dry_run: true to preview the impact without writing.
+    # Mutating — requires user authorization (see SharedTools.execute?).
+    #
+    # @example
+    #   tool = SharedTools::Tools::ReplaceInFilesTool.new(root: "./my-project")
+    #   tool.execute(pattern: "FooBar", replacement: "BazQux", glob: "**/*.rb")
+    #   tool.execute(pattern: "v(\\d+)\\.(\\d+)", replacement: 'v\1.\2-beta', regex: true, dry_run: true)
+    class ReplaceInFilesTool < ::RubyLLM::Tool
+      MAX_BYTES = 5 * 1024 * 1024
+      MAX_LISTED = 100
+      REGEX_TIMEOUT = 2
+      IGNORED_DIRS = %w[.git .hg .svn node_modules .bundle tmp].freeze
+
+      def self.name = 'replace_in_files'
+
+      description "Replace occurrences of a pattern with a replacement across files in root " \
+                  "matching a glob (default '**/*'). Literal by default; set regex true to use a " \
+                  "regular expression (replacement may use \\1 backreferences). Set dry_run true to " \
+                  "preview without writing. Skips binary files and ignored directories."
+
+      parameters do
+        string  :pattern,     description: "Text (or regex if regex=true) to find."
+        string  :replacement, description: "Replacement text. With regex=true, \\1 etc. refer to capture groups.", required: false
+        string  :glob,        description: "Glob of files to search, relative to root. Default '**/*'.", required: false
+        boolean :regex,       description: "Treat pattern as a regular expression. Default false (literal).", required: false
+        boolean :ignore_case, description: "Case-insensitive matching. Default false.", required: false
+        boolean :dry_run,     description: "Report what would change without writing. Default false.", required: false
+      end
+
+      # @param root [String] optional, defaults to the current directory
+      # @param logger [Logger] optional logger
+      def initialize(root: nil, logger: nil)
+        @root = root || Dir.pwd
+        @logger = logger || RubyLLM.logger
+      end
+
+      # @param pattern [String]
+      # @param replacement [String]
+      # @param glob [String]
+      # @param regex [Boolean]
+      # @param ignore_case [Boolean]
+      # @param dry_run [Boolean]
+      #
+      # @return [String, Hash]
+      def execute(pattern:, replacement: "", glob: "**/*", regex: false, ignore_case: false, dry_run: false)
+        @logger.info("#{self.class.name}#execute pattern=#{pattern.inspect} glob=#{glob.inspect} regex=#{regex} dry_run=#{dry_run}")
+
+        return { error: "pattern must not be empty" } if pattern.to_s.empty?
+
+        matcher = build_matcher(pattern, regex, ignore_case)
+        root = File.realpath(@root)
+
+        candidates = candidate_files(glob, root)
+        preview = candidates.filter_map do |abs, rel|
+          content = File.read(abs)
+          next unless text?(content)
+
+          count, = substitute(content, matcher, replacement.to_s, regex)
+          [abs, rel, count] unless count.zero?
+        end
+
+        return format_summary([], 0, dry_run) if preview.empty?
+
+        unless dry_run
+          allowed = SharedTools.execute?(tool: self.class.to_s, stuff: "Replace #{preview.sum { |_, _, c| c }} occurrence(s) across #{preview.size} file(s)")
+          unless allowed
+            @logger.warn("User declined to replace in files")
+            return { error: "User declined to replace in files" }
+          end
+        end
+
+        changed = []
+        total = 0
+        preview.each do |abs, rel, _count|
+          content = File.read(abs)
+          count, updated = substitute(content, matcher, replacement.to_s, regex)
+          next if count.zero?
+
+          total += count
+          changed << [rel, count]
+          File.write(abs, updated) unless dry_run
+        end
+
+        format_summary(changed, total, dry_run)
+      rescue Regexp::TimeoutError
+        @logger.error("#{self.class.name}: regex timed out")
+        { error: "pattern timed out (possible ReDoS); narrow the pattern" }
+      rescue RegexpError => e
+        @logger.error("#{self.class.name}: invalid regex: #{e.message}")
+        { error: "invalid regular expression: #{e.message}" }
+      end
+
+      private
+
+      def build_matcher(pattern, regex, ignore_case)
+        flags = ignore_case ? Regexp::IGNORECASE : 0
+        src = regex ? pattern.to_s : Regexp.escape(pattern.to_s)
+        Regexp.new(src, flags, timeout: REGEX_TIMEOUT)
+      end
+
+      def candidate_files(glob, root)
+        Dir.glob(File.join(root, glob)).filter_map do |abs|
+          next unless File.file?(abs)
+
+          real = begin
+            File.realpath(abs)
+          rescue StandardError
+            next
+          end
+          next unless real == root || real.start_with?(root + File::SEPARATOR)
+
+          rel = real.delete_prefix(root + File::SEPARATOR)
+          next if ignored?(rel)
+          next if File.size(real) > MAX_BYTES
+
+          [real, rel]
+        end
+      end
+
+      def ignored?(rel)
+        parts = rel.split(File::SEPARATOR)
+        IGNORED_DIRS.any? { |dir| parts.include?(dir) }
+      end
+
+      def text?(content)
+        nul = 0.chr
+        content.valid_encoding? && !content.include?(nul)
+      end
+
+      def substitute(content, matcher, replacement, regex)
+        if regex
+          count = content.scan(matcher).size
+          return [0, content] if count.zero?
+
+          [count, content.gsub(matcher, replacement)]
+        else
+          count = 0
+          updated = content.gsub(matcher) { count += 1; replacement }
+          return [0, content] if count.zero?
+
+          [count, updated]
+        end
+      end
+
+      def format_summary(changed, total, dry_run)
+        verb = dry_run ? "Would replace" : "Replaced"
+        return "#{verb} 0 occurrences (no matching files changed)." if changed.empty?
+
+        header = "#{verb} #{total} occurrence#{total == 1 ? '' : 's'} across #{changed.size} file#{changed.size == 1 ? '' : 's'}#{dry_run ? ' (dry run)' : ''}:"
+        lines = changed.first(MAX_LISTED).map { |rel, n| "  #{rel} (#{n})" }
+        lines << "  ... and #{changed.size - MAX_LISTED} more" if changed.size > MAX_LISTED
+        ([header] + lines).join("\n")
+      end
+    end
+  end
+end

data/lib/shared_tools/tools/run_tests_tool.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require_relative "../../shared_tools"
+require_relative "toolchain_helpers"
+
+module SharedTools
+  module Tools
+    # Runs a Ruby project's test suite (RSpec or Minitest) from root and
+    # returns the output with a pass/fail headline. A failing suite is a
+    # normal result (the caller needs to see it), not a tool error. Requires
+    # user authorization (see SharedTools.execute?) since it executes an
+    # external command.
+    #
+    # @example
+    #   tool = SharedTools::Tools::RunTestsTool.new(root: "./my-project")
+    #   tool.execute
+    #   tool.execute(path: "spec/models/user_spec.rb")
+    class RunTestsTool < ::RubyLLM::Tool
+      include ToolchainHelpers
+
+      FRAMEWORKS = %w[rspec minitest].freeze
+      DEFAULT_TIMEOUT = 180
+
+      def self.name = 'run_tests'
+
+      description "Run a Ruby project's test suite from root and report results. Auto-detects RSpec " \
+                  "(spec/ or .rspec) or Minitest (test/ via rake), or set framework explicitly. " \
+                  "Optionally scope to a path. Uses `bundle exec` when a Gemfile exists."
+
+      parameters do
+        string :path,      description: "Limit the run to this spec/test file or directory, relative to root. Optional.", required: false
+        string :framework, description: "Force the framework: rspec or minitest. Default: auto-detect.", required: false
+      end
+
+      # @param root [String] optional, defaults to the current directory
+      # @param logger [Logger] optional logger
+      def initialize(root: nil, logger: nil)
+        @root = root || Dir.pwd
+        @logger = logger || RubyLLM.logger
+      end
+
+      # @param path [String, nil]
+      # @param framework [String, nil]
+      #
+      # @return [String, Hash]
+      def execute(path: nil, framework: nil)
+        @logger.info("#{self.class.name}#execute path=#{path.inspect} framework=#{framework.inspect}")
+
+        fw = (framework || detect_framework).to_s
+        return { error: "could not detect a test framework (no spec/ or test/); set framework" } if fw.empty?
+        return { error: "unknown framework: #{fw} (use #{FRAMEWORKS.join(', ')})" } unless FRAMEWORKS.include?(fw)
+
+        rel = jail_relative(path)
+
+        allowed = SharedTools.execute?(tool: self.class.to_s, stuff: "Run #{fw} tests#{rel ? " (#{rel})" : ''}")
+        unless allowed
+          @logger.warn("User declined to run tests")
+          return { error: "User declined to run tests" }
+        end
+
+        out, err, status = fw == "rspec" ? run_rspec(rel) : run_minitest(rel)
+        toolchain_output(out, err, status,
+                         pass_label: summarize(out, err, "TESTS PASSED"),
+                         fail_label: summarize(out, err, "TESTS FAILED"),
+                         timeout: DEFAULT_TIMEOUT)
+      rescue SecurityError => e
+        @logger.error("#{self.class.name} path denied: #{e.message}")
+        { error: e.message }
+      rescue CommandMissing => e
+        @logger.error("#{self.class.name}: #{e.message} is not available")
+        { error: "#{e.message} is not available (is it in the bundle / installed?)" }
+      end
+
+      private
+
+      def detect_framework
+        return "rspec" if File.directory?(File.join(@root, "spec")) || File.exist?(File.join(@root, ".rspec"))
+        return "minitest" if File.directory?(File.join(@root, "test"))
+
+        ""
+      end
+
+      def run_rspec(rel)
+        args = ["rspec"]
+        args << rel if rel
+        run_in_project(args, use_bundle: true, timeout: DEFAULT_TIMEOUT)
+      end
+
+      def run_minitest(rel)
+        args = ["rake", "test"]
+        args << "TEST=#{rel}" if rel
+        run_in_project(args, use_bundle: true, timeout: DEFAULT_TIMEOUT)
+      end
+
+      # Pull the framework's summary line into the headline when present.
+      def summarize(out, err, label)
+        text = "#{out}\n#{err}"
+        if (m = text.match(/(\d+) examples?, (\d+) failures?(?:, (\d+) errors?)?/))
+          "#{label} (#{m[0]})"
+        elsif (m = text.match(/(\d+) runs?, \d+ assertions?, (\d+) failures?, (\d+) errors?/))
+          "#{label} (#{m[0]})"
+        else
+          label
+        end
+      end
+    end
+  end
+end