bitfab 0.30.0 → 0.30.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1711bd0806a246ec36f15e2bedd0b31d8fe8c9df0aacc922d7ad15a20badf629
-  data.tar.gz: 2e619cf976e2909bdf1bf629cb350e6b761115d4ec9d8372beaacfe5b46adbbf
+  metadata.gz: 4a3e03384934c51dd57e27ac1213dca8f88b41ead5a0980c04bb10ba0ad464d8
+  data.tar.gz: da9c5574b00bd66ba481a78e0f1e0ce4f8e9336b35a7b2e9013498b475622237
 SHA512:
-  metadata.gz: 88d118025460c8aed53e48d4ca16815133c67aa04986688bf1ed84ed506a16c41f11e76fd012cb9c18f6ee06a44f1b42e7de811e78834da737b9e4b260d5a024
-  data.tar.gz: 6c0e746e23dfdf5995c502e3a40cc12c03888c5e783b924049d2cd4152660c8a226b9ce852532440687630449fe84f027a75082602f175619fbe28e38121e9ba
+  metadata.gz: 97f2755495103e92c94258f1763a1066bfc5a1944168e10dec1ad1e0bd24a58ca916791122cf3673f52326ca0d5b89b7ca8324071d40b6c408f3153167f6c95c
+  data.tar.gz: 61ba2d4b92cfa2c2665753319c6acf67dda2d48a547088d1ab47b2e9006835fe869185f3861d4e378f5c8e76167009f2580f385b5f6416467a24ae5b9dce8242

data/lib/bitfab/replay.rb

@@ -2,6 +2,8 @@
 
 require "fileutils"
 require "json"
+require "open3"
+require "timeout"
 
 require_relative "constants"
 require_relative "mock_override"
@@ -179,6 +181,19 @@ module Bitfab
 
       include_db_branch_lease = !environment.nil?
 
+      # An explicit code change always wins; only when the caller passed neither
+      # field do we fall back to the payload the replay wrapper captured from git
+      # and handed over via BITFAB_CODE_CHANGE_PATH. This is what makes an
+      # experiment show its diff even when the run happened outside the
+      # assistant's make-change rails.
+      if code_change_description.nil? && code_change_files.nil?
+        captured = resolve_auto_code_change(name)
+        unless captured.nil?
+          code_change_description = captured[0]
+          code_change_files = captured[1]
+        end
+      end
+
       replay_data = http_client.start_replay(
         trace_function_key,
         effective_limit,
@@ -295,6 +310,177 @@ module Bitfab
       result
     end
 
+    # Read the code-change payload the replay wrapper captured and pointed us at
+    # via BITFAB_CODE_CHANGE_PATH. Returns [description, files] or nil.
+    # Best-effort: any error (no env var, missing file, bad JSON) yields nil so
+    # the replay proceeds with no code change rather than raising.
+    TRUNK_CANDIDATES = ["origin/HEAD", "origin/main", "origin/master", "main", "master"].freeze
+    CC_MAX_FILES = 60
+    CC_MAX_FILE_BYTES = 500_000
+    CC_MAX_TOTAL_BYTES = 2_000_000
+
+    # Auto-capture the code change to attach when the caller passed none. Lives
+    # in replay() (the one call guaranteed to run on every replay) so it works no
+    # matter how the replay was launched. Precedence: a BITFAB_CODE_CHANGE_PATH
+    # override, else the git diff vs trunk. Best-effort: any failure yields nil.
+    # An explicit code_change_files always wins over this.
+    def resolve_auto_code_change(label = nil)
+      return nil if ENV["BITFAB_DISABLE_CODE_CHANGE_CAPTURE"]
+
+      from_env = read_code_change_file
+      return from_env unless from_env.nil?
+
+      capture_code_change_from_git(Dir.pwd, label)
+    end
+
+    def read_code_change_file
+      path = ENV["BITFAB_CODE_CHANGE_PATH"]
+      return nil if path.nil? || path.empty?
+
+      begin
+        parsed = JSON.parse(File.read(path))
+        files = parsed["files"]
+        # A malformed payload (non-array, or entries that aren't hashes) must
+        # yield no code change, never crash normalize_code_change_files.
+        files = nil unless files.is_a?(Array) && files.all?(Hash)
+        description = parsed["description"]
+        description = nil unless description.is_a?(String)
+        return nil if files.nil? && description.nil?
+
+        [description, files]
+      rescue
+        nil
+      end
+    end
+
+    def git(cwd, args)
+      # capture3 so git's stderr (e.g. "not a git repository") is swallowed, not
+      # leaked to the host process's console.
+      out, _err, status = Timeout.timeout(30) do
+        Open3.capture3("git", *args, chdir: cwd)
+      end
+      return nil unless status.success?
+
+      # Tag as UTF-8 and scrub invalid bytes so blob contents compare cleanly
+      # against the UTF-8 working-file reads and never break JSON.generate later
+      # (a non-UTF-8 file that slips past the null-byte check would otherwise
+      # abort the whole start-replay request).
+      out.force_encoding("UTF-8").scrub
+    rescue
+      nil
+    end
+
+    def cc_ref_exists?(root, ref)
+      !git(root, ["rev-parse", "--verify", "#{ref}^{object}"]).nil?
+    end
+
+    # Returns [base, from_trunk]; from_trunk is false on the HEAD fallback.
+    def cc_resolve_base(root)
+      forced = ENV["BITFAB_CODE_CHANGE_BASE"]
+      if forced && cc_ref_exists?(root, forced)
+        mb = git(root, ["merge-base", "HEAD", forced])
+        return [mb.strip, true] if mb && !mb.strip.empty?
+
+        rp = git(root, ["rev-parse", "--verify", forced])
+        return (rp && !rp.strip.empty?) ? [rp.strip, true] : nil
+      end
+      TRUNK_CANDIDATES.each do |candidate|
+        next unless cc_ref_exists?(root, candidate)
+
+        mb = git(root, ["merge-base", "HEAD", candidate])
+        return [mb.strip, true] if mb && !mb.strip.empty?
+      end
+      cc_ref_exists?(root, "HEAD") ? ["HEAD", false] : nil
+    end
+
+    def cc_blob_bytes(root, base, path)
+      out = git(root, ["cat-file", "-s", "#{base}:#{path}"])
+      (out && !out.strip.empty?) ? out.strip.to_i : 0
+    rescue
+      0
+    end
+
+    def cc_working_bytes(root, path)
+      File.size(File.join(root, path))
+    rescue
+      0
+    end
+
+    def capture_code_change_from_git(cwd, label = nil)
+      root = git(cwd, ["rev-parse", "--show-toplevel"])
+      return nil if root.nil? || root.strip.empty?
+
+      root = root.strip
+      resolved = cc_resolve_base(root)
+      return nil if resolved.nil?
+
+      base, from_trunk = resolved
+
+      tracked = git(root, ["diff", "--name-status", "--no-renames", "-z", base, "--", ":!.bitfab"]) || ""
+      untracked = git(root, ["ls-files", "--others", "--exclude-standard", "-z", "--", ":!.bitfab"]) || ""
+
+      entries = cc_parse_name_status_z(tracked)
+      untracked.split("\0").reject(&:empty?).each { |p| entries << ["A", p] }
+      return nil if entries.empty?
+
+      files = []
+      total = 0
+      entries.each do |status, path|
+        break if files.length >= CC_MAX_FILES
+
+        # Skip oversized files by size BEFORE reading their full contents, so a
+        # huge changed file can't OOM/stall replay just to be discarded.
+        before_bytes = (status == "A") ? 0 : cc_blob_bytes(root, base, path)
+        after_bytes = (status == "D") ? 0 : cc_working_bytes(root, path)
+        next if before_bytes > CC_MAX_FILE_BYTES || after_bytes > CC_MAX_FILE_BYTES
+
+        # Normalize CRLF -> LF on both sides: git's blob is already LF-normalized
+        # (autocrlf clean), so a raw CRLF working file would otherwise skew every
+        # line as changed. Comparing/storing LF keeps the diff meaningful.
+        before = (status == "A") ? "" : (git(root, ["show", "#{base}:#{path}"]) || "").gsub("\r\n", "\n")
+        after = (status == "D") ? "" : cc_read_working_file(root, path).gsub("\r\n", "\n")
+        next if before == after
+
+        size = before.bytesize + after.bytesize
+        next if total + size > CC_MAX_TOTAL_BYTES ||
+          cc_looks_binary?(before) || cc_looks_binary?(after)
+
+        total += size
+        files << {"path" => path, "before" => before, "after" => after}
+      end
+      return nil if files.empty?
+
+      subject = git(root, ["log", "-1", "--format=%s", "HEAD"])
+      subject = subject ? subject.strip : ""
+      head = ((label && !label.strip.empty?) ? label.strip : nil) || (subject.empty? ? nil : subject) || "Working-tree change"
+      word = (files.length == 1) ? "file" : "files"
+      against = from_trunk ? "vs trunk" : "uncommitted (vs HEAD)"
+      ["#{head} (#{files.length} #{word} changed #{against})", files]
+    rescue
+      nil
+    end
+
+    def cc_parse_name_status_z(raw)
+      parts = raw.split("\0").reject(&:empty?)
+      out = []
+      i = 0
+      while i + 1 < parts.length
+        out << [parts[i][0], parts[i + 1]]
+        i += 2
+      end
+      out
+    end
+
+    def cc_read_working_file(root, path)
+      File.read(File.join(root, path), encoding: "UTF-8")
+    rescue
+      ""
+    end
+
+    def cc_looks_binary?(str)
+      str[0, 8000].include?("\0")
+    end
+
     def write_replay_result_file(result)
       result_path = ENV["BITFAB_REPLAY_RESULT_PATH"]
       return if result_path.nil? || result_path.empty?

data/lib/bitfab/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bitfab
-  VERSION = "0.30.0"
+  VERSION = "0.30.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bitfab
 version: !ruby/object:Gem::Version
-  version: 0.30.0
+  version: 0.30.1
 platform: ruby
 authors:
 - Harvest Team