binpacker 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d0c30480b18ff759a0611116ea6c21fd5e5034525aa4ebfa95ab65fb3f2fdf2
-  data.tar.gz: 9b273d060dfbef0b2812bc2617e7eeaed00bee6247c6381d51d8b075132b28e8
+  metadata.gz: 991ac5d941b69573b4f6d03c211ff862465a91ee31ddd82f5ce8d8150a2d4f0d
+  data.tar.gz: 8ad2f245f73a46a4fdd64272049835c36d3b2dc4a0bb5df9cf67f851789ae59a
 SHA512:
-  metadata.gz: d765fe4fc0741dbd13445707da9f937e4571090697c6767ddfa9ec3391e0a9a9a76935fab3ba820eb410e5bcb1d69c617668e514dd4656c46134b1a15cc87097
-  data.tar.gz: 03cd6766727a30e69e259c356b53461ac54bbed7d454904535a91e9e448c4b3fe6750104e63bf7bd1ceed5eb111f47f11e88231397d58ae52304339dcdbbfca9
+  metadata.gz: 4345168c76cd0e072ab8f0775df54fe705e13f873a1f7f8ce764b897f42f91f75c5b4b0dee07329b577200230a7707a90284e73b554a339798575e084ce93f15
+  data.tar.gz: 40408cf8b88b878033226df711fbf3e57c217293b85b6eb7f94f55289eb7740d02dcc66598c5f594a3cd21821b5186eb38942c7e03747838a6487ccc37e018d1

data/exe/binpacker-worker

@@ -3,19 +3,34 @@
 
 require "json"
 require "optparse"
+require "set"
 require "tempfile"
 
+begin
+  require "minitest"
+rescue LoadError
+  # Minitest not installed — rspec-only use
+end
+
 def run_rspec(files, wid, rspec_args)
   outfile = Tempfile.new("binpacker-rspec-out")
+  progress_outfile = Tempfile.new("binpacker-rspec-progress")
   outfile.close
+  progress_outfile.close
+
   cmd = [
     "rspec",
     "--format", "json", "--out", outfile.path,
-    "--format", "progress", "--out", "/dev/stderr",
+    "--format", "progress", "--out", progress_outfile.path,
     *rspec_args,
     *files
   ]
-  success = system(*cmd)
+  system(*cmd, exception: false)
+  exit_status = $?.exitstatus || 1
+
+  if File.exist?(progress_outfile.path) && File.size(progress_outfile.path) > 0
+    $stderr.write File.read(progress_outfile.path, encoding: "UTF-8")
+  end
 
   data = (File.exist?(outfile.path) && File.size(outfile.path) > 0) ? JSON.parse(File.read(outfile.path, encoding: "UTF-8")) : {}
   examples = data["examples"] || []
@@ -25,65 +40,170 @@ def run_rspec(files, wid, rspec_args)
     { file: ex["file_path"], name: ex["full_description"] || ex["description"], time: ex["run_time"] || 0.0 }
   end
 
-  outfile.unlink
-  [$?.exitstatus || 1, results, examples.size, (summary["failure_count"] || 0) == 0 ? examples.size : examples.size - summary["failure_count"]]
+  [exit_status, results, examples.size, (summary["failure_count"] || 0) == 0 ? examples.size : examples.size - summary["failure_count"]]
+ensure
+  outfile&.unlink
+  progress_outfile&.unlink
+end
+
+def add_project_load_paths
+  %w[lib test].each do |path|
+    expanded = File.expand_path(path)
+    $LOAD_PATH.unshift(expanded) if Dir.exist?(expanded) && !$LOAD_PATH.include?(expanded)
+  end
+end
+
+def run_minitest_after_run_hooks
+  return unless Minitest.class_variable_defined?(:@@after_run)
+
+  Minitest.class_variable_get(:@@after_run).reverse_each(&:call)
+end
+
+def run_minitest(tests, wid, minitest_args)
+  unless defined?(Minitest)
+    $stderr.puts "[worker-#{wid}] minitest is not available"
+    return [1, [], 0, 0]
+  end
+
+  def Minitest.autorun; end
+  add_project_load_paths
+
+  options = Minitest.process_args(minitest_args.dup)
+  options[:io] = $stderr
+  Minitest.seed = options[:seed]
+  srand Minitest.seed
+
+  selected = []
+  tests.group_by { |test| test["file"] }.each do |file, test_entries|
+    path = File.expand_path(file)
+    requested_names = test_entries.map { |test| test["name"] }.to_set
+    klasses_before = Minitest::Runnable.runnables.dup
+    $stderr.puts "[worker-#{wid}] loading #{file}"
+    load path
+
+    (Minitest::Runnable.runnables - klasses_before).each do |klass|
+      klass.filter_runnable_methods(options).each do |method_name|
+        full_name = "#{klass}##{method_name}"
+        selected << [klass, method_name, file, full_name] if requested_names.include?(full_name)
+      end
+    end
+  rescue StandardError => e
+    $stderr.puts "[worker-#{wid}] minitest load failed for #{file}: #{e.class}: #{e.message}"
+    return [1, [], 0, 0]
+  end
+
+  return [0, [], 0, 0] if selected.empty?
+
+  timing_reporter = TimingReporter.new
+  reporter = Minitest::CompositeReporter.new
+  reporter << Minitest::SummaryReporter.new($stderr, options)
+  reporter << Minitest::ProgressReporter.new($stderr, options) unless options[:quiet]
+  reporter << timing_reporter
+
+  Minitest.reporter = reporter
+  Minitest.init_plugins(options)
+  Minitest.reporter = nil
+
+  selected_files = selected.to_h { |_klass, _method_name, file, full_name| [full_name, file] }
+
+  Minitest.parallel_executor.start if Minitest.parallel_executor.respond_to?(:start)
+  reporter.start
+  hook_error = nil
+  begin
+    selected.each do |klass, method_name, _file, _full_name|
+      klass.run(klass, method_name, reporter)
+    end
+  ensure
+    Minitest.parallel_executor.shutdown if Minitest.parallel_executor.respond_to?(:shutdown)
+    reporter.report
+    begin
+      run_minitest_after_run_hooks
+    rescue StandardError => e
+      hook_error = e
+      $stderr.puts "[worker-#{wid}] minitest after_run failed: #{e.class}: #{e.message}"
+    end
+  end
+
+  failures = timing_reporter.results.count { |result| !result.passed? }
+  results = timing_reporter.results.map do |result|
+    full_name = "#{result.klass}##{result.name}"
+    {
+      file: selected_files.fetch(full_name, result.source_location.first),
+      name: full_name,
+      time: result.time
+    }
+  end
+
+  exit_code = reporter.passed? && hook_error.nil? ? 0 : 1
+  passed = results.size - failures
+  [exit_code, results, results.size, passed]
 end
 
-def run_minitest(files, wid, _args)
-  results = []
-  exit_code = 0
-  files.each do |file|
-    start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    s = system("ruby", "-Ilib:test", file, exception: false)
-    elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
-    results << { file: file, name: file, time: elapsed }
-    exit_code = s.exitstatus unless s.success?
+if defined?(Minitest)
+  class TimingReporter < Minitest::AbstractReporter
+    attr_reader :results
+
+    def initialize
+      super()
+      @results = []
+    end
+
+    def record(result)
+      @results << result
+    end
   end
-  [exit_code, results, results.size, exit_code == 0 ? results.size : 0]
 end
 
 options = { runner: "rspec", id: 0 }
 rspec_args = []
+minitest_args = []
 OptionParser.new do |opts|
   opts.on("--runner RUNNER", "rspec or minitest") { |v| options[:runner] = v }
   opts.on("--id ID", "Worker ID") { |v| options[:id] = v.to_i }
   opts.on("--rspec-arg ARG", "Pass-through to rspec") { |v| rspec_args << v }
+  opts.on("--minitest-arg ARG", "Pass-through to minitest") { |v| minitest_args << v }
 end.parse!
 
 wid = options[:id]
+exit_code = 0
 $stderr.puts "[worker-#{wid}] #{options[:runner]} worker started"
-$stdout.puts JSON.generate({ type: "ready" })
-$stdout.flush
-
-tests = []
-$stdin.each_line do |line|
-  data = JSON.parse(line.strip)
-  break if data["type"] == "done"
-  tests << data
-rescue JSON::ParserError
-  $stderr.puts "[worker-#{wid}] skip: #{line.strip[0..60]}"
-end
 
-if tests.empty?
-  $stdout.puts JSON.generate({ type: "result", exit_code: 0, passed: true, total: 0, passed_count: 0 })
+loop do
+  $stdout.puts JSON.generate({ type: "ready" })
   $stdout.flush
-  exit 0
-end
 
-files = tests.map { |t| t["file"] }.uniq
-$stderr.puts "[worker-#{wid}] #{files.size} files, #{tests.size} test entries"
+  tests = []
+  done_or_eof = false
+  $stdin.each_line do |line|
+    data = JSON.parse(line.strip)
+    if data["type"] == "done"
+      done_or_eof = true
+      break
+    end
+    tests << data
+  rescue JSON::ParserError
+    $stderr.puts "[worker-#{wid}] skip: #{line.strip[0..60]}"
+  end
 
-exit_code, results, total, passed = case options[:runner]
-when "rspec"   then run_rspec(files, wid, rspec_args)
-when "minitest" then run_minitest(files, wid, [])
-else
-  $stderr.puts "[worker-#{wid}] unknown runner: #{options[:runner]}"
-  [1, [], 0, 0]
-end
+  break if done_or_eof && tests.empty?
+  break if tests.empty? && ($stdin.eof? || $stdin.closed?)
+
+  files = tests.map { |t| t["file"] }.uniq
+  $stderr.puts "[worker-#{wid}] batch: #{files.size} files, #{tests.size} entries"
 
-results.each do |r|
-  $stdout.puts JSON.generate({ type: "timing", file: r[:file], name: r[:name], time: r[:time] })
+  exit_code, results, total, passed = case options[:runner]
+  when "rspec"   then run_rspec(files, wid, rspec_args)
+  when "minitest" then run_minitest(tests, wid, minitest_args)
+  else
+    $stderr.puts "[worker-#{wid}] unknown runner: #{options[:runner]}"
+    [1, [], 0, 0]
+  end
+
+  results.each do |r|
+    $stdout.puts JSON.generate({ type: "timing", file: r[:file], name: r[:name], time: r[:time] })
+  end
+  $stdout.puts JSON.generate({ type: "batch_result", exit_code: exit_code, passed: exit_code == 0, total: total, passed_count: passed })
+  $stdout.flush
 end
-$stdout.puts JSON.generate({ type: "result", exit_code: exit_code, passed: exit_code == 0, total: total, passed_count: passed })
-$stdout.flush
-exit exit_code
+
+exit exit_code || 0

data/lib/binpacker/calibration.rb

@@ -13,10 +13,13 @@ module Binpacker
       @timing = Timing.new(config.timing_file)
     end
 
-    def run(tests)
+    # Runs each Test serially and appends its measured Weight to the Timing file.
+    # With incremental: true, Tests that already have a measured Weight are skipped.
+    def run(tests, incremental: false)
+      targets = incremental ? unmeasured(tests) : tests
       results = []
 
-      tests.each do |test|
+      targets.each do |test|
         elapsed = run_single(test)
         results << { file: test.file, name: test.name, time: elapsed }
       end
@@ -27,21 +30,30 @@ module Binpacker
 
     private
 
+    def unmeasured(tests)
+      measured = @timing.load_raw
+      tests.reject { |test| measured.key?([@timing.normalize_path(test.file), test.name]) }
+    end
+
     def run_single(test)
       outfile = Tempfile.new("binpacker-cal")
       outfile.close
 
       start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
+      # At file granularity the Test's name is its file path (see Test
+      # discovery), so there is no single example/method to filter — run the
+      # whole file. A per-test filter would match nothing and measure only
+      # load time.
+      file_unit = test.name == test.file
+
       case @config.test_runner
       when "rspec"
-        cmd = [
-          "rspec", test.file,
-          "--example", test.name,
-          "--format", "json", "--out", outfile.path
-        ]
+        cmd = ["rspec", test.file, "--format", "json", "--out", outfile.path]
+        cmd.push("--example", test.name) unless file_unit
       when "minitest"
-        cmd = ["ruby", "-Ilib:test", test.file, "--name", test.name]
+        cmd = ["ruby", "-Ilib:test", test.file]
+        cmd.push("--name", "/^#{Regexp.escape(test.name)}$/") unless file_unit
       else
         raise ConfigError, "unsupported runner for calibration: #{@config.test_runner}"
       end

data/lib/binpacker/cli.rb

@@ -14,6 +14,13 @@ module Binpacker
       @command = nil
       @profile = nil
       @passthrough = []
+      @quiet = false
+      @incremental = false
+      @report_path = nil
+      @skill_list = false
+      @skill_path = false
+      @skill_describe = false
+      @skill_name = nil
       parse!
     end
 
@@ -23,6 +30,12 @@ module Binpacker
         cmd_calibrate
       when "run"
         cmd_run
+      when "init"
+        cmd_init
+      when "skill"
+        cmd_skill
+      when "describe"
+        cmd_describe
       when "--version", "-v"
         puts "binpacker #{Binpacker::VERSION}"
       when "--help", "-h", nil
@@ -51,6 +64,30 @@ module Binpacker
         opts.on("--help", "Show help") do
           @command ||= "--help"
         end
+
+        opts.on("--quiet", "Suppress worker output") do
+          @quiet = true
+        end
+
+        opts.on("--incremental", "Calibrate only tests without timing data") do
+          @incremental = true
+        end
+
+        opts.on("--report PATH", "(run) Write a JSON run report to PATH") do |v|
+          @report_path = v
+        end
+
+        opts.on("--list", "(skill) List bundled skills") do
+          @skill_list = true
+        end
+
+        opts.on("--path", "(skill) Print the SKILL.md path for <name>") do
+          @skill_path = true
+        end
+
+        opts.on("--describe", "(skill) Report project state and next skill") do
+          @skill_describe = true
+        end
       end
 
       # Extract passthrough arguments after "--"
@@ -60,7 +97,50 @@ module Binpacker
       end
 
       remaining = parser.parse(@args)
-      @command = remaining.shift
+      # A positional command wins; otherwise keep any command an option set
+      # (e.g. --version), so `binpacker --version` isn't clobbered to nil.
+      @command = remaining.shift || @command
+      @skill_name = remaining.shift
+    end
+
+    def cmd_init
+      config_path = Pathname.pwd.join("binpacker.yml")
+      if config_path.exist?
+        puts "binpacker.yml already exists at #{config_path}"
+        exit 1
+      end
+
+      framework = detect_framework
+      unless ProjectState::SUPPORTED_FRAMEWORKS.include?(framework)
+        $stderr.puts "Detected #{framework} — binpacker supports rspec and minitest only."
+        $stderr.puts "No binpacker.yml was created."
+        exit 1
+      end
+      pattern = framework == "minitest" ? "test/**/*_test.rb" : "spec/**/*_spec.rb"
+      runner = framework
+
+      yaml = <<~YAML
+        profiles:
+          default:
+            test_runner: #{runner}
+            workers: auto
+            timing_file: binpacker.timings
+            test_pattern: "#{pattern}"
+            scheduler:
+              algorithm: multifit
+              steal_enabled: true
+          ci:
+            extends: default
+            workers: 4
+      YAML
+
+      config_path.write(yaml)
+      puts "Created #{config_path}"
+      puts "Detected test framework: #{framework}"
+      puts ""
+      puts "Next steps:"
+      puts "  1. binpacker calibrate   (seed timing data)"
+      puts "  2. binpacker run          (run in parallel)"
     end
 
     def cmd_calibrate
@@ -68,32 +148,121 @@ module Binpacker
       discovery_klass = config.test_runner == "rspec" ? RSpecDiscovery : MinitestDiscovery
       tests = discovery_klass.new(config).enumerate
 
-      puts "Calibrating #{tests.size} tests..."
       cal = Calibration.new(config)
-      timings = cal.run(tests)
+
+      if @incremental
+        puts "Calibrating (incremental) #{tests.size} tests..."
+      else
+        puts "Calibrating #{tests.size} tests..."
+      end
+
+      timings = cal.run(tests, incremental: @incremental)
 
       total = timings.sum { |t| t[:time] }
-      puts "Calibration complete: #{tests.size} tests in #{total.round(2)}s"
+      measured = timings.size
+      skipped = tests.size - measured
+      summary = "Calibration complete: #{measured} #{pluralize(measured, 'test')} in #{total.round(2)}s"
+      summary += " (#{skipped} skipped, already measured)" if @incremental && skipped.positive?
+      puts summary
       puts "Timing data written to #{config.timing_file}"
     end
 
+    def cmd_skill
+      return cmd_describe if @skill_describe
+
+      if @skill_path
+        path = Skills.path(@skill_name)
+        if path
+          puts path
+        else
+          $stderr.puts "unknown skill: #{@skill_name}"
+          exit 1
+        end
+      elsif @skill_name && !@skill_list
+        print_skill(@skill_name)
+      else
+        list_skills
+      end
+    end
+
+    def cmd_describe
+      state = ProjectState.new
+      puts "binpacker project state:"
+      puts "  config (binpacker.yml): #{state.config_present? ? 'present' : 'missing'}"
+      puts "  timing data:            #{state.timing_present? ? 'present' : 'missing'}"
+      puts "  test framework:         #{state.framework || 'not detected'}"
+      puts "  CI wired for binpacker: #{state.ci_wired? ? 'yes' : 'no'}"
+      puts ""
+
+      unless state.supported_framework?
+        puts "binpacker supports rspec and minitest; #{state.framework} is not supported yet."
+        puts "Setup cannot proceed against a #{state.framework} suite."
+        return
+      end
+
+      rec = state.recommendation
+      puts "Recommended next skill: #{rec}"
+      puts "Run `binpacker skill #{rec}` to load its instructions."
+    end
+
+    def list_skills
+      skills = Skills.list
+      if skills.empty?
+        puts "No bundled skills found."
+        return
+      end
+      puts "Bundled skills:"
+      skills.each { |s| puts "  #{s[:name]}" }
+      puts ""
+      puts "Print a skill's instructions with `binpacker skill <name>`."
+    end
+
+    def print_skill(name)
+      unless Skills.exist?(name)
+        $stderr.puts "unknown skill: #{name}"
+        $stderr.puts "Run `binpacker skill` to list bundled skills."
+        exit 1
+      end
+
+      puts "# Skill: #{name}"
+      puts "# Source: #{Skills.path(name)}"
+      puts ""
+      puts Skills.body(name)
+    end
+
     def cmd_run
       config = Config.new(profile: @profile)
-      orchestrator = Orchestrator.new(config, passthrough: @passthrough)
+      report_path = @report_path || config.report_file
+      orchestrator = Orchestrator.new(
+        config, passthrough: @passthrough, quiet: @quiet, report_path: report_path
+      )
 
       puts "binpacker starting (#{config.worker_count} workers, profile: #{config.profile})"
       result = orchestrator.run
+      puts "Run report written to #{report_path}" if report_path
+      unit = test_unit_label(config)
 
       if result[:passed]
-        puts "All #{result[:total]} examples passed across #{config.worker_count} workers."
+        puts "All #{result[:total]} #{pluralize(result[:total], unit)} passed across #{config.worker_count} workers."
         exit 0
+      elsif result[:empty_filter]
+        puts "No tests matched the Minitest filter."
+        exit 1
       else
         failed = result[:total] - result[:passed_count]
-        puts "#{failed}/#{result[:total]} examples failed."
+        puts "#{failed}/#{result[:total]} #{pluralize(failed, unit)} failed."
         exit 1
       end
     end
 
+    def test_unit_label(config)
+      config.test_runner == "rspec" ? "example" : "test"
+    end
+
+    def pluralize(count, word)
+      count == 1 ? word : "#{word}s"
+    end
+
     def print_help
       puts <<~HELP
         binpacker #{Binpacker::VERSION}
@@ -101,16 +270,31 @@ module Binpacker
         Commands:
           run          Execute tests across worker processes
           calibrate    Run tests serially to generate timing data
+          init         Create binpacker.yml with auto-detected settings
+          describe     Report project state and recommend the next skill
+          skill        List or print bundled agent skills
 
         Options:
           --profile NAME   Select profile from binpacker.yml
+          --incremental    (calibrate) Measure only tests without timing data
+          --report PATH    (run) Write a JSON run report to PATH
+          --list           (skill) List bundled skills
+          --path           (skill) Print the SKILL.md path for <name>
+          --describe       (skill) Report project state and next skill
           --help           Show this message
 
         Examples:
+          binpacker init
           binpacker run --profile ci
           binpacker run -- --tag ~slow
-          binpacker calibrate
+          binpacker calibrate --incremental
+          binpacker describe
+          binpacker skill binpacker-setup
       HELP
     end
+
+    def detect_framework
+      ProjectState.new.framework || "rspec"
+    end
   end
 end

data/lib/binpacker/config.rb

@@ -10,13 +10,15 @@ module Binpacker
     DEFAULTS = {
       "test_runner" => "rspec",
       "workers" => "auto",
+      "test_granularity" => "file",
       "timing_file" => "binpacker.timings",
       "test_pattern" => "spec/**/*_spec.rb",
       "test_exclude" => [],
+      "report_file" => nil,
       "scheduler" => {
         "strategy" => "static",
         "steal_enabled" => false,
-        "algorithm" => "lpt"
+        "algorithm" => "multifit"
       }
     }.freeze
 
@@ -77,6 +79,7 @@ module Binpacker
 
     def build_profile(name)
       profiles = @raw.fetch("profiles", {})
+      return DEFAULTS.dup if profiles.empty? && name == "default"
       entry = profiles[name]
       raise ConfigError, "profile '#{name}' not found in binpacker.yml" unless entry
       parent = entry["extends"]