rspec-sprint 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc37bb933dee52c1c7afe48cabacb970bf1f6188e2587ac032001185a77755ed
-  data.tar.gz: 3b440d548798f9ce169bcb44f65760ea86858cf554d5359a0166d074ca3a54d2
+  metadata.gz: e5f37a1b9a05bd46d0463b1d169c0a5ec0b5a6cac40e55c4c099c68145ce24e3
+  data.tar.gz: d667edc83a97950ac00ab8d5745fd2a0119259f6b909e1cb9f023e36a03399be
 SHA512:
-  metadata.gz: 1b895e63670890d0717b8e663eba88a9c5494ebc266869570f2d2d34a925ea25a82a469279d426ff6a89d1d0a608a586490577b22eee79567fb2c8a03f79e09d
-  data.tar.gz: '0868189200f1c5aa80d3d0b50aca73c4dcf1146ea769f1f1044199872ce02aaf943282a28cbc382f615f2b1a2484c5cde05da1331181dbe7968bf27558925bad'
+  metadata.gz: 6bf1ffd9151437bd41de0f718a2957b6449325d52870ae4e46b8ba8c9f850a418a793b630f1f9eae5b2c3605fe2d034ec7adae1d390e81c5c01a89b5a51fcee0
+  data.tar.gz: fd968c8e59d68dbb47b82640777f71b4a2915678719d897d054196725088cdee71839aacb9e54a4aa7482e0fca3719a586963785916debf0a61965bdf5d09e98

data/README.md

@@ -6,9 +6,15 @@
 
 ```
 $ bundle exec rspec-sprint doctor
-factory が suite の 47% (local実測)。最上位は :user（420回, うち直接生成は 30回 = カスケード）。
-  → 不要 association を trait へ退避 / build_stubbed / let_it_be / FactoryDefault
-...
+rspec-sprint doctor — 上位2件 (信号があった項目のみ):
+
+1. factory が suite の 44% (local実測)。最上位は :tenant（689回, うち直接生成は 30回）
+   → 不要 association を trait へ退避 / build_stubbed / let_it_be / FactoryDefault
+   想定削減: factory 比率を半減できれば最大 22% 相当（local実測）
+
+2. 上位5例が suite 時間の 84%。最遅: "ExportedDatum zip生成" (193034ms)
+   → 外部I/O・sleep・実ブラウザ依存を切り出す
+   想定削減: 上位例を半減できれば最大 42% 相当（local実測）
 ```
 
 ## Installation
@@ -24,32 +30,55 @@ end
 
 Then run `bundle install`.
 
-**Prerequisite:** Add to your `spec/spec_helper.rb`:
+**Prerequisite:** Add to your `spec/spec_helper.rb` (or `rails_helper.rb`):
 
 ```ruby
 require "test_prof"
 ```
 
+This enables FactoryProf for Rule① (factory_dominance). Without it, the other rules still run.
+
 ## Usage
 
+### Diagnose
+
 Run the doctor command to diagnose your suite and get prescriptions ranked by ROI:
 
 ```
 $ bundle exec rspec-sprint doctor
 ```
 
-To target a subset of specs (faster feedback during investigation):
+Target a subset of specs for faster feedback:
 
 ```
 $ bundle exec rspec-sprint doctor -- spec/models
 ```
 
-Snapshot comparison (coming in v0.2.0):
+Skip saving a snapshot:
 
 ```
 $ bundle exec rspec-sprint doctor --no-snapshot
 ```
 
+### Compare against previous run
+
+Show delta vs the most recent snapshot (requires at least one prior `doctor` run):
+
+```
+$ bundle exec rspec-sprint doctor --compare-last
+前回比 +6.9s (+15%)  factory time 40% → 48%  [2026-06-18 09:00]
+```
+
+### Save a long-term baseline
+
+Record the current performance as a named baseline for future reference:
+
+```
+$ bundle exec rspec-sprint compare --save-baseline
+```
+
+The baseline is saved to `.rspec-sprint/baseline.json` and is never auto-pruned, unlike the rolling snapshots used by `--compare-last`.
+
 The command exits 0 whether or not findings are reported, so it is safe to run in CI as an advisory step.
 
 ## Why not just test-prof?
@@ -62,7 +91,7 @@ Concretely, rspec-sprint applies three opinionated heuristics to your numbers:
 - **path_group_skew** — one spec directory accounts for a disproportionate share of slowness
 - **slow_examples_concentration** — a handful of examples dominate the tail
 
-For each finding it emits a ranked prescription (e.g. "retire unused associations to a trait, switch to `build_stubbed`") rather than leaving interpretation to you.
+For each finding it emits a ranked prescription rather than leaving interpretation to you.
 
 Even when test-prof is not installed, FactoryBot is absent, or the suite fails partway through, `rspec-sprint doctor` degrades gracefully and tells you what it could and could not measure.
 
@@ -77,21 +106,17 @@ Even when test-prof is not installed, FactoryBot is absent, or the suite fails p
 
 ## Status
 
-v0.1.0 — install-day tested, dogfood confirmed.
+**v1.0.0** — API stable. Dogfood confirmed on 3 Rails apps.
 
-**Dogfood result (SonicGarden/aegis, 2026-06-18):**
+| App | Bottleneck found | Prescription |
+|-----|-----------------|--------------|
+| SonicGarden/aegis | factory_dominance — :tenant factory 689 calls (44%) | build_stubbed / let_it_be |
+| SonicGarden/carecollabo | slow_examples_concentration — zip export test 193s | stub external I/O |
+| SonicGarden/testra | slow_examples_concentration — SSRF guard test 3.5s | stub network calls |
 
-```
-$ bundle exec rspec-sprint doctor -- spec/models spec/policies
-
-1. path group spec/models が suite 時間の 92% (local実測)
-   → spec/models を別CIジョブに分離し fast suite から切り出す（候補）
-
-2. factory が suite の 44%。最上位は :tenant（689回）
-   → 不要な association を trait へ退避 / build_stubbed / let_it_be
-```
+All three findings were repo-specific with concrete numbers and actionable prescriptions.
 
-Both findings are repo-specific with concrete numbers — not generic advice.
+**Snapshot schema v1 is frozen** — field additions are OK, deletions and type changes are not.
 
 ## License
 

data/lib/rspec_sprint/cli.rb

@@ -3,6 +3,7 @@
 require "thor"
 require_relative "collector"
 require_relative "doctor"
+require_relative "fix"
 
 module RspecSprint
   class CLI < Thor
@@ -52,6 +53,43 @@ module RspecSprint
                                    save_baseline: options[:save_baseline])
     end
 
+    desc "fix [TARGET]", "確定的な処方箋を自動適用する（verify-and-revert）"
+    long_desc <<~DESC
+      ホットな factory に紐づく let/let!{create} を let_it_be 化します。
+
+      適用モード（既定）: suite を 1 回実行してプロファイルを取り、ROI 上位ファイルの
+      候補を適用→再実行→緑 & 速くなれば採用、そうでなければ自動リバートします。
+      採用分は working tree に未コミットで残ります（git diff で確認して commit）。
+
+        bundle exec rspec-sprint fix let-it-be
+        bundle exec rspec-sprint fix let-it-be --limit 5
+        bundle exec rspec-sprint fix let-it-be --all
+
+      dry-run モード: 検出・提案のみ（適用しない）
+
+        bundle exec rspec-sprint fix let-it-be --dry-run
+
+      TARGET は現在 let-it-be のみ対応。
+    DESC
+    option :dry_run, type: :boolean, default: false,
+      desc: "検出と提案のみ（適用しない）"
+    option :limit, type: :numeric, default: 10,
+      desc: "適用するファイル上限（ROI 降順）。--all で全ファイル"
+    option :all, type: :boolean, default: false,
+      desc: "全ファイルを処理する（--limit を無視）"
+    def fix(target = "let-it-be")
+      unless target == "let-it-be"
+        puts "未対応の TARGET です。現在は let-it-be のみ対応しています。"
+        return
+      end
+      result = Collector.new(rspec_args: []).run
+      if options[:dry_run]
+        puts Fix.dry_run(result, dir: ".")
+      else
+        puts Fix.apply(result, dir: ".", limit: options[:limit], all: options[:all])
+      end
+    end
+
     default_command :doctor
   end
 end

data/lib/rspec_sprint/fix.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require "open3"
+require "fileutils"
+require "json"
+require "digest"
+require_relative "normalizer"
+require_relative "doctor"
+require_relative "fixers/let_it_be/detector"
+require_relative "fixers/let_it_be/report"
+require_relative "fixers/let_it_be/formatter"
+require_relative "fixers/let_it_be/rewriter"
+require_relative "fixers/let_it_be/verifier"
+require_relative "fixers/let_it_be/apply_formatter"
+
+module RspecSprint
+  # `fix --dry-run let-it-be` の orchestrator。suite は CLI 側で 1 回走らせ済みで、
+  # その Result（rspec JSON + FactoryProf JSON のパス）を受け取る。FactoryProf は
+  # hard precondition（設計）: 無ければ診断不能としてヒントを返す。
+  module Fix
+    module_function
+
+    def dry_run(result, dir: ".")
+      return Doctor.factory_prof_missing_hint unless result.factory_prof?
+
+      snapshot = Normalizer.new(
+        rspec_json: result.rspec_json_path,
+        factory_prof_json: result.factory_prof_path
+      ).call
+
+      candidates = []
+      let_bang_count = 0
+      spec_files(dir).each do |path|
+        source = File.read(path)
+        candidates.concat(Fixers::LetItBe::Detector.scan(source, file_path: relative(path, dir)))
+        let_bang_count += Fixers::LetItBe::Detector.count_let_bang_create(source)
+      end
+
+      report = Fixers::LetItBe::Report.build(
+        candidates: candidates,
+        factories: snapshot.factories,
+        let_bang_count: let_bang_count
+      )
+      Fixers::LetItBe::Formatter.format(report)
+    end
+
+    # let/let! 候補を verify-and-revert で適用する。
+    # limit: 処理するファイル上限（ROI 降順）。all: true なら全ファイルを処理。
+    def apply(result, dir: ".", limit: 10, all: false)
+      return Doctor.factory_prof_missing_hint unless result.factory_prof?
+      return git_not_repo_hint unless git_repo?(dir)
+      return recipe_not_loaded_hint(dir) unless let_it_be_recipe_loaded?(dir)
+
+      snapshot = Normalizer.new(
+        rspec_json: result.rspec_json_path,
+        factory_prof_json: result.factory_prof_path
+      ).call
+
+      factory_time = snapshot.factories.each_with_object({}) do |f, h|
+        h[f.name.to_s] = f.top_level_time.to_f
+      end
+
+      files_with_candidates = {}
+      spec_files(dir).each do |abs_path|
+        rel_path = relative(abs_path, dir)
+        source = File.read(abs_path)
+        cands = Fixers::LetItBe::Detector.scan_all(source, file_path: rel_path)
+        files_with_candidates[abs_path] = cands unless cands.empty?
+      end
+
+      return "変換可能な候補が見つかりませんでした（let/let! の単一 create 本体が対象）。" \
+             " まず `rspec-sprint fix let-it-be --dry-run` で確認してください。" if files_with_candidates.empty?
+
+      sorted = files_with_candidates.sort_by do |_path, cands|
+        -cands.map { |c| factory_time[c.factory_name.to_s].to_f }.sum
+      end
+
+      target_files = all ? sorted : sorted.first(limit)
+
+      verifier = Fixers::LetItBe::Verifier.new(runner: rspec_runner(dir), dir: dir)
+      file_results = target_files.map do |abs_path, cands|
+        verifier.verify_file(abs_path, cands)
+      end
+
+      Fixers::LetItBe::ApplyFormatter.format(file_results)
+    end
+
+    def spec_files(dir)
+      Dir.glob(File.join(dir, "spec/**/*_spec.rb")).sort
+    end
+
+    def relative(path, dir)
+      base = File.expand_path(dir)
+      File.expand_path(path).delete_prefix("#{base}/")
+    end
+
+    def git_repo?(dir)
+      _, status = Open3.capture2e("git", "-C", dir, "rev-parse", "--git-dir")
+      status.success?
+    end
+
+    def git_not_repo_hint
+      "エラー: git リポジトリが見つかりません。`fix` 適用は git が必要です（復元保証のため）。"
+    end
+
+    def let_it_be_recipe_loaded?(dir)
+      helper_files = Dir.glob(File.join(dir, "spec/{spec_helper,rails_helper}.rb"))
+      helper_files.any? do |f|
+        content = File.read(f)
+        content.include?("test_prof/recipes/rspec/let_it_be") ||
+          content.include?("RSpecLetItBe")
+      end
+    rescue StandardError
+      false
+    end
+
+    def recipe_not_loaded_hint(dir)
+      <<~MSG
+        エラー: `let_it_be` recipe がロードされていません。
+
+        spec/spec_helper.rb または spec/rails_helper.rb に以下を追加してください:
+
+          require "test_prof/recipes/rspec/let_it_be"
+
+        追加後、もう一度 `rspec-sprint fix let-it-be` を実行してください。
+      MSG
+    end
+
+    def rspec_runner(dir)
+      out_dir = File.join(dir, "tmp", "rspec_sprint", "verify")
+      FileUtils.mkdir_p(out_dir)
+      ->(path) {
+        out_path = File.join(out_dir, "#{Digest::MD5.hexdigest(path)[0..7]}_verify.json")
+        _, status = Open3.capture2e(
+          "bundle", "exec", "rspec", path,
+          "--format", "json", "--out", out_path,
+          chdir: dir
+        )
+        green = status.exitstatus&.zero? || false
+        duration = parse_verify_duration(out_path)
+        {green: green, duration: duration}
+      }
+    end
+
+    def parse_verify_duration(out_path)
+      return 0.0 unless File.exist?(out_path) && !File.zero?(out_path)
+
+      data = JSON.parse(File.read(out_path))
+      data.dig("summary", "duration")&.to_f || 0.0
+    rescue JSON::ParserError
+      0.0
+    end
+  end
+end

data/lib/rspec_sprint/fixers/let_it_be/apply_formatter.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RspecSprint
+  module Fixers
+    module LetItBe
+      module ApplyFormatter
+        module_function
+
+        def format(results)
+          lines = ["rspec-sprint fix let-it-be", ""]
+
+          results.each do |r|
+            lines << file_line(r)
+          end
+
+          lines << ""
+          lines << summary_line(results)
+          lines << ""
+          lines << "採用分は working tree に未コミットです。`git diff` で確認して commit してください。"
+          lines.join("\n")
+        end
+
+        def file_line(r)
+          path = r.file.to_s
+          case r.status
+          when :accepted
+            "#{path}: 採用 #{r.applied.size} 件 #{time_range(r.baseline_s, r.after_s)}"
+          when :bisect_partial
+            "#{path}: 採用 #{r.applied.size} 件 [bisect]"
+          when :reverted_slow
+            "#{path}: リバート（速度改善不足）#{r.reverted.size} 件 #{time_range(r.baseline_s, r.after_s)}"
+          when :reverted_red
+            "#{path}: リバート（赤）#{r.reverted.size} 件"
+          when :skipped_dirty
+            "#{path}: スキップ（git-dirty）#{r.skipped.size} 件"
+          when :skipped_unstable
+            "#{path}: スキップ（baseline 不安定）#{r.skipped.size} 件"
+          else
+            "#{path}: 不明なステータス #{r.status}"
+          end
+        end
+
+        def time_range(baseline_s, after_s)
+          return "" unless baseline_s && after_s
+
+          pct = baseline_s > 0 ? ((baseline_s - after_s) / baseline_s * 100).round : 0
+          "(#{baseline_s.round(1)}s → #{after_s.round(1)}s, -#{pct}%)"
+        end
+
+        def summary_line(results)
+          total_applied = results.sum { |r| r.applied.size }
+          accepted_files = results.count { |r| r.status == :accepted || r.status == :bisect_partial }
+          baseline_total = results.filter_map(&:baseline_s).sum
+          after_total = results.filter_map(&:after_s).sum
+          time_part = baseline_total > 0 && after_total > 0 ? " #{time_range(baseline_total, after_total)}" : ""
+          "合計: 採用 #{total_applied} 件 / #{accepted_files} ファイル#{time_part}"
+        end
+      end
+    end
+  end
+end

data/lib/rspec_sprint/fixers/let_it_be/detector.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "rubocop-ast"
+
+module RspecSprint
+  module Fixers
+    module LetItBe
+      # 1 件の autocorrect 候補。let_name / factory_name は Symbol。kind は :let or :let_bang。
+      Candidate = Struct.new(:let_name, :factory_name, :line, :file_path, :kind,
+                             keyword_init: true) do
+        def initialize(let_name:, factory_name:, line:, file_path:, kind: :let)
+          super
+        end
+      end
+
+      # spec ソースを AST で走査し、本体が「単一の create(:factory) 呼び出し」だけの
+      # `let(:x) { ... }` を候補として返す純粋関数。挙動を変える変換なので、安全性は
+      # 後段（verify/revert, 本プラン対象外）に委ね、ここでは確定パターンだけ拾う。
+      class Detector
+        # block:
+        #   レシーバ無し let に sym 引数 1 つ（$ で let 名を捕捉）
+        #   引数なしブロック (args)
+        #   本体は レシーバが無 or FactoryBot の create、第1引数は sym（$ で factory 名を捕捉）
+        PATTERN = ::RuboCop::AST::NodePattern.new(<<~PAT)
+          (block
+            (send nil? :let (sym $_))
+            (args)
+            (send {nil? (const nil? :FactoryBot)} :create (sym $_) ...))
+        PAT
+
+        # 同形だが `let!`。eager → once でセマンティクスが変わるため安全変換の対象外。
+        # 「対象外だが隣接する let!{create} がどれだけあるか」を提示するために数えるだけ。
+        LET_BANG_PATTERN = ::RuboCop::AST::NodePattern.new(<<~PAT)
+          (block
+            (send nil? :let! (sym $_))
+            (args)
+            (send {nil? (const nil? :FactoryBot)} :create (sym $_) ...))
+        PAT
+
+        def self.scan(source, file_path: nil)
+          each_match(source, PATTERN).map do |let_name, factory_name, node|
+            Candidate.new(
+              let_name: let_name,
+              factory_name: factory_name,
+              line: node.loc.line,
+              file_path: file_path,
+              kind: :let
+            )
+          end
+        end
+
+        # let と let! の両方を候補として返す（apply モード用）。line 昇順。
+        def self.scan_all(source, file_path: nil)
+          let_cands = each_match(source, PATTERN).map do |let_name, factory_name, node|
+            Candidate.new(let_name: let_name, factory_name: factory_name,
+                          line: node.loc.line, file_path: file_path, kind: :let)
+          end
+          let_bang_cands = each_match(source, LET_BANG_PATTERN).map do |let_name, factory_name, node|
+            Candidate.new(let_name: let_name, factory_name: factory_name,
+                          line: node.loc.line, file_path: file_path, kind: :let_bang)
+          end
+          (let_cands + let_bang_cands).sort_by(&:line)
+        end
+
+        # 安全変換できない let!{single create} の件数（lazy/let! 比を示すため）。
+        def self.count_let_bang_create(source)
+          each_match(source, LET_BANG_PATTERN).size
+        end
+
+        # AST を1回パースし、pattern に一致する block を [let_name, factory_name, node] で返す。
+        def self.each_match(source, pattern)
+          processed = ::RuboCop::AST::ProcessedSource.new(source.to_s, RUBY_VERSION.to_f)
+          ast = processed.ast
+          return [] if ast.nil?
+
+          matches = []
+          ast.each_node(:block) do |node|
+            captures = pattern.match(node)
+            next unless captures
+
+            let_name, factory_name = captures
+            matches << [let_name, factory_name, node]
+          end
+          matches
+        end
+        private_class_method :each_match
+      end
+    end
+  end
+end

data/lib/rspec_sprint/fixers/let_it_be/formatter.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RspecSprint
+  module Fixers
+    module LetItBe
+      # dry-run レポートを端末向けに整形する。
+      #
+      # 見出しは「変換可能候補の件数」と「対象外の let!{create} 件数（lazy/let! 比）」。
+      # 上限 share は実収量と乖離しうる（候補が参照する factory のコストの大半が let! や
+      # 直接 create 由来のことがある）ため、誤誘導する「推定削減」ではなく
+      # 「上限値・実収量ではない」と明示して補足に降格する。
+      module Formatter
+        module_function
+
+        def format(report)
+          return none(report.let_bang_count) if report.candidates.empty?
+
+          lines = [
+            "rspec-sprint fix --dry-run (let_it_be)",
+            "変換可能候補（lazy let{create}）: #{report.candidates.size} 件",
+            let_bang_line(report.let_bang_count),
+            ""
+          ].compact
+          report.candidates.each do |c|
+            lines << "#{c.file_path}:#{c.line}"
+            lines << "  - let(:#{c.let_name}) { create(:#{c.factory_name}) }"
+            lines << "  + let_it_be(:#{c.let_name}) { create(:#{c.factory_name}) }"
+            lines << ""
+          end
+          lines << "参考（上限値・実収量ではない）: 候補が参照する factory は factory time の最大 #{pct(report)}%。" \
+                   "実際の削減は適用+再実行で測定（未実施）。"
+          lines << "注意: これは dry-run です。適用はまだ行いません（緑のまま速くなるか実測する verify は次段）。"
+          lines.join("\n")
+        end
+
+        def none(let_bang_count)
+          if let_bang_count.to_i.positive?
+            "変換可能な lazy let{create} 候補は 0 件。" \
+              "ただし let!{create} が #{let_bang_count} 件あります" \
+              "（eager→once でセマンティクスが変わるため安全変換不可。apply モードでは verify 付きで対応：`rspec-sprint fix let-it-be`）。"
+          else
+            "該当する let{create} 候補は見つかりませんでした（単一 create 本体の let のみ対象）。"
+          end
+        end
+
+        def let_bang_line(count)
+          return nil unless count.to_i.positive?
+
+          "対象外: let!{create} #{count} 件（eager→once でセマンティクスが変わるため安全変換不可。apply モードでは verify 付きで対応：`rspec-sprint fix let-it-be`）"
+        end
+
+        def pct(report)
+          (report.upper_bound_share * 100).round
+        end
+      end
+    end
+  end
+end

data/lib/rspec_sprint/fixers/let_it_be/report.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RspecSprint
+  module Fixers
+    module LetItBe
+      # 候補と factory プロファイルから「factory time 削減の上限割合」を出す。
+      # 上限値: 候補が参照する factory の top_level_time を「全てこの候補で消える」と
+      # 仮定した最大値。実際にどの call site がホットかは集計データから特定できないため
+      # （設計 Open Question 1）、これは upper bound であって実収量ではない。
+      module Report
+        module_function
+
+        Result = Struct.new(:candidates, :upper_bound_share, :let_bang_count, keyword_init: true)
+
+        def build(candidates:, factories:, let_bang_count: 0)
+          denominator = factories.sum { |f| f.top_level_time.to_f }
+          referenced = candidates.map { |c| c.factory_name.to_s }.uniq
+          numerator = factories
+            .select { |f| referenced.include?(f.name.to_s) }
+            .sum { |f| f.top_level_time.to_f }
+          share = denominator.zero? ? 0.0 : numerator / denominator
+          Result.new(candidates: candidates, upper_bound_share: share, let_bang_count: let_bang_count)
+        end
+      end
+    end
+  end
+end

data/lib/rspec_sprint/fixers/let_it_be/rewriter.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "rubocop-ast"
+require "parser/source/tree_rewriter"
+
+module RspecSprint
+  module Fixers
+    module LetItBe
+      module Rewriter
+        module_function
+
+        # source（String）と candidates（Array[Candidate]）を受け取り、
+        # 各候補行の let(/let!( を let_it_be( に書き換えた source を返す。
+        # ファイル I/O を持たない純粋関数。パース不能時は source をそのまま返す。
+        def rewrite(source, candidates)
+          return source if candidates.empty?
+
+          processed = ::RuboCop::AST::ProcessedSource.new(source.to_s, RUBY_VERSION.to_f)
+          return source if processed.ast.nil?
+
+          target_lines = candidates.map(&:line).to_set
+          tree_rewriter = ::Parser::Source::TreeRewriter.new(processed.buffer)
+
+          processed.ast.each_node(:block) do |node|
+            next unless target_lines.include?(node.loc.line)
+
+            send_node = node.children[0]
+            next unless send_node&.send_type?
+            next unless %i[let let!].include?(send_node.method_name)
+
+            tree_rewriter.replace(send_node.loc.selector, "let_it_be")
+          end
+
+          tree_rewriter.process
+        end
+      end
+    end
+  end
+end

data/lib/rspec_sprint/fixers/let_it_be/verifier.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "open3"
+require_relative "rewriter"
+
+module RspecSprint
+  module Fixers
+    module LetItBe
+      # verify_file の戻り値。
+      FileResult = Struct.new(
+        :file,        # String — 絶対パス
+        :applied,     # Array[Candidate] — 採用（working tree に残す）
+        :reverted,    # Array[Candidate] — 試したが戻した
+        :skipped,     # Array[Candidate] — 試さなかった（dirty/unstable）
+        :baseline_s,  # Float|nil — baseline の平均（秒）
+        :after_s,     # Float|nil — after の平均（秒）
+        :status,      # :accepted | :reverted_slow | :reverted_red |
+                      # :bisect_partial | :skipped_dirty | :skipped_unstable
+        keyword_init: true
+      )
+
+      # runner:     call(path) -> {green: Boolean, duration: Float}
+      # git_clean:  call(path) -> Boolean（省略時は git status --porcelain を実行）
+      class Verifier
+        def initialize(runner:, dir: ".", git_clean: nil)
+          @runner = runner
+          @dir = dir
+          @git_clean_fn = git_clean
+        end
+
+        def verify_file(path, candidates)
+          unless file_clean?(path)
+            return FileResult.new(file: path, applied: [], reverted: [], skipped: candidates,
+                                  baseline_s: nil, after_s: nil, status: :skipped_dirty)
+          end
+
+          source_backup = File.read(path)
+
+          b1 = @runner.call(path)
+          b2 = @runner.call(path)
+
+          unless b1[:green] && b2[:green]
+            return FileResult.new(file: path, applied: [], reverted: [], skipped: candidates,
+                                  baseline_s: nil, after_s: nil, status: :skipped_unstable)
+          end
+
+          baseline_s = (b1[:duration] + b2[:duration]) / 2.0
+
+          rewritten = Rewriter.rewrite(source_backup, candidates)
+          File.write(path, rewritten)
+
+          r1 = @runner.call(path)
+          r2 = @runner.call(path)
+
+          if r1[:green] && r2[:green]
+            after_s = (r1[:duration] + r2[:duration]) / 2.0
+            if improvement_sufficient?(baseline_s, after_s)
+              return FileResult.new(file: path, applied: candidates, reverted: [], skipped: [],
+                                    baseline_s: baseline_s, after_s: after_s, status: :accepted)
+            else
+              File.write(path, source_backup)
+              return FileResult.new(file: path, applied: [], reverted: candidates, skipped: [],
+                                    baseline_s: baseline_s, after_s: after_s, status: :reverted_slow)
+            end
+          else
+            File.write(path, source_backup)
+            bisect(path, candidates, source_backup, baseline_s)
+          end
+        end
+
+        private
+
+        def improvement_sufficient?(baseline_s, after_s)
+          delta = baseline_s - after_s
+          delta >= 0.5 || (baseline_s > 0 && delta / baseline_s >= 0.05)
+        end
+
+        def bisect(path, candidates, source_backup, baseline_s)
+          safe = []
+          candidates.each do |candidate|
+            trial = Rewriter.rewrite(source_backup, [candidate])
+            File.write(path, trial)
+            r = @runner.call(path)
+            safe << candidate if r[:green]
+            File.write(path, source_backup)
+          end
+
+          if safe.empty?
+            return FileResult.new(file: path, applied: [], reverted: candidates, skipped: [],
+                                  baseline_s: baseline_s, after_s: nil, status: :reverted_red)
+          end
+
+          final = Rewriter.rewrite(source_backup, safe)
+          File.write(path, final)
+
+          r = @runner.call(path)
+          unless r[:green]
+            File.write(path, source_backup)
+            return FileResult.new(file: path, applied: [], reverted: candidates, skipped: [],
+                                  baseline_s: baseline_s, after_s: nil, status: :reverted_red)
+          end
+
+          FileResult.new(file: path, applied: safe, reverted: candidates - safe, skipped: [],
+                         baseline_s: baseline_s, after_s: nil, status: :bisect_partial)
+        end
+
+        def file_clean?(path)
+          if @git_clean_fn
+            @git_clean_fn.call(path)
+          else
+            default_git_clean(path)
+          end
+        end
+
+        def default_git_clean(path)
+          out, status = Open3.capture2e("git", "status", "--porcelain", path, chdir: @dir)
+          status.success? && out.strip.empty?
+        end
+      end
+    end
+  end
+end

data/lib/rspec_sprint/normalizer.rb

@@ -10,7 +10,7 @@ module RspecSprint
   class Normalizer
     # One factory's profile. top_level_ratio is the cascade signal: low ratio
     # means the factory is built mostly via associations, not directly.
-    Factory = Struct.new(:name, :total_count, :top_level_count, :total_time, keyword_init: true) do
+    Factory = Struct.new(:name, :total_count, :top_level_count, :total_time, :top_level_time, keyword_init: true) do
       def top_level_ratio
         return 0.0 if total_count.nil? || total_count.zero?
 
@@ -98,7 +98,8 @@ module RspecSprint
           name: s.fetch("name"),
           total_count: s.fetch("total_count", 0),
           top_level_count: s.fetch("top_level_count", 0),
-          total_time: s.fetch("total_time", 0.0)
+          total_time: s.fetch("total_time", 0.0),
+          top_level_time: s.fetch("top_level_time", 0.0)
         )
       end
     end

data/lib/rspec_sprint/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RspecSprint
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspec-sprint
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - yasu551
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-06-18 00:00:00.000000000 Z
+date: 2026-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-prof
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-ast
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.30'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.30'
 description: |
   rspec-sprint doctor runs your suite once (via test-prof's FactoryProf + rspec's
   JSON formatter), interprets the output against opinionated heuristics, and asserts
@@ -59,6 +73,13 @@ files:
 - lib/rspec_sprint/diagnosis.rb
 - lib/rspec_sprint/doctor.rb
 - lib/rspec_sprint/finding.rb
+- lib/rspec_sprint/fix.rb
+- lib/rspec_sprint/fixers/let_it_be/apply_formatter.rb
+- lib/rspec_sprint/fixers/let_it_be/detector.rb
+- lib/rspec_sprint/fixers/let_it_be/formatter.rb
+- lib/rspec_sprint/fixers/let_it_be/report.rb
+- lib/rspec_sprint/fixers/let_it_be/rewriter.rb
+- lib/rspec_sprint/fixers/let_it_be/verifier.rb
 - lib/rspec_sprint/formatter.rb
 - lib/rspec_sprint/normalizer.rb
 - lib/rspec_sprint/ranker.rb