churn_vs_complexity 1.5.2 → 1.6.1

data/lib/churn_vs_complexity/diff/serializer.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module ChurnVsComplexity
+  module Diff
+    module Serializer
+      module Json
+        def self.serialize(reference:, before:, after:)
+          before_gammas = gammas_from(before)
+          after_gammas = gammas_from(after)
+          degraded, improved, unchanged_count = classify_changes(before_gammas, after_gammas)
+
+          JSON.generate(
+            reference:, current: 'HEAD',
+            overall: overall_summary(before_gammas.values, after_gammas.values),
+            degraded:, improved:, unchanged: unchanged_count,
+          )
+        end
+
+        def self.gammas_from(result)
+          result[:values_by_file].transform_values { |v| GammaScore.calculate(v[0], v[1]).round(2) }
+        end
+
+        def self.overall_summary(before_scores, after_scores)
+          before_mean = mean(before_scores)
+          after_mean = mean(after_scores)
+          { mean_gamma_before: before_mean, mean_gamma_after: after_mean,
+            direction: direction(before_mean, after_mean), }
+        end
+
+        def self.classify_changes(before_gammas, after_gammas)
+          all_files = (before_gammas.keys + after_gammas.keys).uniq
+          grouped = all_files.group_by { |f| classify_file(before_gammas[f], after_gammas[f]) }
+
+          [
+            entries_for(grouped[:degraded], before_gammas, after_gammas),
+            entries_for(grouped[:improved], before_gammas, after_gammas),
+            (grouped[:unchanged] || []).size,
+          ]
+        end
+
+        def self.entries_for(files, before_gammas, after_gammas)
+          (files || []).map { |f| file_entry(f, before_gammas[f], after_gammas[f]) }
+        end
+
+        def self.classify_file(old_g, new_g)
+          return :unchanged if old_g.nil? || new_g.nil? || (old_g - new_g).abs < 0.01
+          return :degraded if new_g > old_g
+
+          :improved
+        end
+
+        def self.file_entry(file, old_g, new_g)
+          pct = old_g.positive? ? (((new_g - old_g) / old_g) * 100).round(0) : 0
+          sign = pct.positive? ? '+' : ''
+          { file:, gamma_before: old_g, gamma_after: new_g, change: "#{sign}#{pct}%" }
+        end
+
+        def self.mean(scores)
+          return 0.0 if scores.empty?
+
+          (scores.sum.to_f / scores.size).round(2)
+        end
+
+        def self.direction(before, after)
+          diff = after - before
+          return 'unchanged' if diff.abs < 0.5
+
+          diff.positive? ? 'degraded' : 'improved'
+        end
+
+        private_class_method :gammas_from, :overall_summary, :classify_changes,
+                             :classify_file, :entries_for, :file_entry, :mean, :direction
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/diff.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'diff/config'
+require_relative 'diff/checker'
+require_relative 'diff/serializer'
+
+module ChurnVsComplexity
+  module Diff
+  end
+end

data/lib/churn_vs_complexity/file_selector.rb

@@ -10,6 +10,10 @@ module ChurnVsComplexity
         ['.rb']
       when :javascript
         ['.js', '.jsx', '.ts', '.tsx']
+      when :python
+        ['.py']
+      when :go
+        ['.go']
       else
         raise Error, "Unsupported language: #{language}"
       end
@@ -104,5 +108,27 @@ module ChurnVsComplexity
                        convert_to_absolute_path: true,)
       end
     end
+
+    module Python
+      DEFAULT_EXCLUDES = %w[venv .venv env .env __pycache__ .tox site-packages].freeze
+
+      def self.excluding(excluded)
+        Excluding.new(FileSelector.extensions(:python), DEFAULT_EXCLUDES + excluded)
+      end
+
+      def self.predefined(included:, excluded:)
+        Predefined.new(included:, extensions: FileSelector.extensions(:python), excluded: DEFAULT_EXCLUDES + excluded)
+      end
+    end
+
+    module Go
+      def self.excluding(excluded)
+        Excluding.new(FileSelector.extensions(:go), excluded)
+      end
+
+      def self.predefined(included:, excluded:)
+        Predefined.new(included:, extensions: FileSelector.extensions(:go), excluded:)
+      end
+    end
   end
 end

data/lib/churn_vs_complexity/focus/checker.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module ChurnVsComplexity
+  module Focus
+    class Checker
+      def initialize(engine:, subcommand:, serializer:, baseline_path:)
+        @engine = engine
+        @subcommand = subcommand
+        @serializer = serializer
+        @baseline_path = baseline_path
+      end
+
+      def check(folder:)
+        resolved_path = resolve_baseline_path(folder)
+        case @subcommand
+        when :start then run_start(folder, resolved_path)
+        when :end then run_end(folder, resolved_path)
+        end
+      end
+
+      private
+
+      def run_start(folder, baseline_path)
+        raw_result = @engine.check(folder:)
+        entries = RiskAnnotator.annotate(raw_result[:values_by_file])
+
+        baseline = {
+          timestamp: Time.now.utc.iso8601,
+          files: entries.map { |e| { file: e[:file], gamma_score: e[:gamma_score] } },
+        }
+
+        File.write(baseline_path, JSON.generate(baseline))
+        "Baseline saved to #{baseline_path} (#{entries.size} files)"
+      end
+
+      def run_end(folder, baseline_path)
+        raw_result = @engine.check(folder:)
+        current_entries = RiskAnnotator.annotate(raw_result[:values_by_file])
+
+        baseline = load_baseline(baseline_path)
+        @serializer.serialize(baseline:, current: current_entries)
+      end
+
+      def load_baseline(baseline_path)
+        return unless File.exist?(baseline_path)
+
+        JSON.parse(File.read(baseline_path))
+      end
+
+      def resolve_baseline_path(folder)
+        return @baseline_path if File.absolute_path?(@baseline_path)
+
+        File.join(folder, @baseline_path)
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/focus/config.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  module Focus
+    class Config
+      DEFAULT_BASELINE_PATH = '.focus-baseline.json'
+
+      def initialize(
+        language:,
+        subcommand:,
+        serializer: :json,
+        since: nil,
+        excluded: [],
+        baseline_path: DEFAULT_BASELINE_PATH,
+        complexity_validator: ComplexityValidator,
+        since_validator: Normal::SinceValidator,
+        **options
+      )
+        @language = language
+        @subcommand = subcommand.to_sym
+        @serializer = serializer
+        @since = since
+        @excluded = excluded
+        @baseline_path = baseline_path
+        @complexity_validator = complexity_validator
+        @since_validator = since_validator
+        @options = options
+      end
+
+      def validate!
+        LanguageValidator.validate!(@language)
+        @since_validator.validate!(since: @since, relative_period: nil)
+        @complexity_validator.validate!(@language)
+        validate_subcommand!
+      end
+
+      def checker
+        Checker.new(
+          engine: normal_engine,
+          subcommand: @subcommand,
+          serializer: focus_serializer,
+          baseline_path: @baseline_path,
+        )
+      end
+
+      private
+
+      def normal_engine
+        Normal::Config.new(language: @language, serializer: :none, since: @since, excluded: @excluded).checker
+      end
+
+      def validate_subcommand!
+        return if %i[start end].include?(@subcommand)
+
+        raise ValidationError, "Invalid focus subcommand: #{@subcommand}. Use 'start' or 'end'."
+      end
+
+      def focus_serializer
+        case @subcommand
+        when :start then nil # start doesn't need a serializer
+        when :end then Serializer::Json
+        end
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/focus/serializer.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module ChurnVsComplexity
+  module Focus
+    module Serializer
+      module Json
+        def self.serialize(baseline:, current:)
+          baseline ? build_report(baseline, current) : build_fallback_report(current)
+        end
+
+        def self.build_report(baseline, current)
+          before_gammas = baseline['files'].to_h { |f| [f['file'], f['gamma_score']] }
+          after_gammas = current.to_h { |e| [e[:file], e[:gamma_score]] }
+          touched = find_touched_files(before_gammas, after_gammas)
+
+          JSON.generate(
+            session: session_data(started: baseline['timestamp'], files_modified: touched.size),
+            impact: impact_data(before: mean(before_gammas.values), after: mean(after_gammas.values)),
+            files_touched: touched,
+          )
+        end
+
+        def self.build_fallback_report(current)
+          after_scores = current.map { |e| e[:gamma_score] }
+
+          report = {
+            warning: 'No baseline found. Comparing against current state only.',
+            session: session_data(started: nil, files_modified: 0),
+            impact: { mean_gamma_before: nil, mean_gamma_after: mean(after_scores), direction: 'unknown' },
+            files_touched: [],
+          }
+          JSON.generate(report)
+        end
+
+        def self.session_data(started:, files_modified:)
+          { started:, ended: Time.now.utc.iso8601, files_modified: }
+        end
+
+        def self.impact_data(before:, after:)
+          { mean_gamma_before: before, mean_gamma_after: after, direction: direction(before, after) }
+        end
+
+        def self.mean(scores)
+          return 0.0 if scores.empty?
+
+          (scores.sum.to_f / scores.size).round(2)
+        end
+
+        def self.direction(before, after)
+          diff = after - before
+          return 'unchanged' if diff.abs < 0.5
+
+          diff.positive? ? 'degraded' : 'improved'
+        end
+
+        def self.find_touched_files(before_files, after_files)
+          all_files = (before_files.keys + after_files.keys).uniq
+          all_files.filter_map { |file| build_touched_entry(file, before_files[file], after_files[file]) }
+        end
+
+        def self.build_touched_entry(file, old_gamma, new_gamma)
+          return if old_gamma == new_gamma
+
+          {
+            file:,
+            gamma_before: old_gamma, gamma_after: new_gamma,
+            complexity_added: new_gamma ? (new_gamma - (old_gamma || 0)).round(2) : 0,
+            has_tests: test_file_exists?(file),
+            recommendation: recommend(old_gamma, new_gamma),
+          }
+        end
+
+        def self.test_file_exists?(file)
+          return false unless file
+
+          base = File.basename(file, File.extname(file))
+          ext = File.extname(file)
+          %w[test spec].any? do |dir|
+            File.exist?(File.join(dir, File.dirname(file), "#{base}_#{dir == 'test' ? 'test' : 'spec'}#{ext}"))
+          end
+        end
+
+        def self.recommend(old_gamma, new_gamma)
+          return 'File removed.' if new_gamma.nil?
+          return 'New file. Add test coverage.' if old_gamma.nil?
+
+          new_gamma > old_gamma ? 'Complexity increased. Consider adding tests.' : 'Complexity decreased. Good.'
+        end
+
+        private_class_method :build_report, :build_fallback_report, :session_data, :impact_data,
+                             :mean, :direction, :find_touched_files, :build_touched_entry,
+                             :test_file_exists?, :recommend
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/focus.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'focus/config'
+require_relative 'focus/checker'
+require_relative 'focus/serializer'
+
+module ChurnVsComplexity
+  module Focus
+  end
+end

data/lib/churn_vs_complexity/gamma_score.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  module GammaScore
+    EPSILON = 0.0001
+
+    def self.calculate(churn, complexity)
+      c = churn.to_f + EPSILON
+      x = complexity.to_f + EPSILON
+      (2 * c * x) / (c + x)
+    end
+  end
+end

data/lib/churn_vs_complexity/gate/checker.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module ChurnVsComplexity
+  module Gate
+    class Checker
+      class Result
+        def initialize(json, passed:)
+          @json = json
+          @passed = passed
+        end
+
+        def passed?
+          @passed
+        end
+
+        def to_s
+          @json
+        end
+      end
+
+      def initialize(engine:, serializer:, max_gamma:)
+        @engine = engine
+        @serializer = serializer
+        @max_gamma = max_gamma
+      end
+
+      def check(folder:)
+        raw_result = @engine.check(folder:)
+        json = @serializer.serialize(raw_result, max_gamma: @max_gamma)
+        Result.new(json, passed: JSON.parse(json)['passed'])
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/gate/config.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  module Gate
+    class Config
+      DEFAULT_MAX_GAMMA = 25
+
+      def initialize(
+        language:,
+        serializer: :json,
+        max_gamma: DEFAULT_MAX_GAMMA,
+        since: nil,
+        excluded: [],
+        complexity_validator: ComplexityValidator,
+        since_validator: Normal::SinceValidator,
+        **options
+      )
+        @language = language
+        @serializer = serializer
+        @max_gamma = max_gamma
+        @since = since
+        @excluded = excluded
+        @complexity_validator = complexity_validator
+        @since_validator = since_validator
+        @options = options
+      end
+
+      def validate!
+        LanguageValidator.validate!(@language)
+        @since_validator.validate!(since: @since, relative_period: nil)
+        @complexity_validator.validate!(@language)
+      end
+
+      def checker
+        normal_config = Normal::Config.new(
+          language: @language,
+          serializer: :none,
+          since: @since,
+          excluded: @excluded,
+        )
+        Checker.new(engine: normal_config.checker, serializer: gate_serializer, max_gamma: @max_gamma)
+      end
+
+      private
+
+      def gate_serializer
+        case @serializer
+        when :json then Serializer::Json
+        end
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/gate/serializer.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module ChurnVsComplexity
+  module Gate
+    module Serializer
+      module Json
+        class << self
+          def serialize(result, max_gamma:)
+            violations = find_violations(result[:values_by_file], max_gamma)
+
+            JSON.generate(
+              passed: violations.empty?,
+              threshold: { max_gamma: },
+              violations:,
+            )
+          end
+
+          private
+
+          def find_violations(values_by_file, max_gamma)
+            values_by_file.filter_map do |file, values|
+              gamma = GammaScore.calculate(values[0], values[1]).round(2)
+              next unless gamma > max_gamma
+
+              exceeds_pct = (((gamma - max_gamma) / max_gamma) * 100).round(0)
+              { file:, gamma_score: gamma, exceeds_by: "#{exceeds_pct}%" }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/gate.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'gate/serializer'
+require_relative 'gate/config'
+require_relative 'gate/checker'
+
+module ChurnVsComplexity
+  module Gate
+  end
+end

data/lib/churn_vs_complexity/git_strategy.rb

@@ -2,6 +2,8 @@
 
 module ChurnVsComplexity
   class GitStrategy
+    EMPTY_TREE_SHA = '4b825dc642cb6eb9a060e54bf8d69288fbee4904'
+
     def initialize(folder:)
       @repo = Git.open(folder)
       @folder = folder
@@ -20,15 +22,14 @@ module ChurnVsComplexity
 
     def surrounding(commit:)
       current = object(commit)
-      is_head = current.sha == @repo.object('HEAD').sha
-      next_commit = is_head ? nil : @repo.log(100_000).find { |c| c.parents.map(&:sha).include?(current.sha) }
-      [current.parent&.sha, next_commit&.sha]
+      child_sha = `git -C #{@folder} log --reverse --ancestry-path #{current.sha}..HEAD --format=%H`.lines.first&.chomp
+      next_commit = child_sha&.empty? ? nil : child_sha
+      [current.parent&.sha, next_commit]
     end
 
     def changes(commit:)
       commit_object = @repo.object(commit)
-      base = commit_object.parent
-      commit_object.diff(base).map do |change|
+      diff_from_parent(commit_object).map do |change|
         { path: change.path, type: change.type.to_sym }
       end
     end
@@ -58,5 +59,12 @@ module ChurnVsComplexity
       command = "(cd #{worktree_folder} && git worktree remove -f #{worktree_folder}) > /dev/null 2>&1"
       `#{command}`
     end
+
+    private
+
+    def diff_from_parent(commit_object)
+      base = commit_object.parent
+      base ? base.diff(commit_object) : @repo.diff(EMPTY_TREE_SHA, commit_object.sha)
+    end
   end
 end

data/lib/churn_vs_complexity/hotspots/checker.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  module Hotspots
+    class Checker
+      def initialize(engine:, serializer:)
+        @engine = engine
+        @serializer = serializer
+      end
+
+      def check(folder:)
+        raw_result = @engine.check(folder:)
+        @serializer.serialize(raw_result)
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/hotspots/config.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  module Hotspots
+    class Config
+      def initialize(
+        language:,
+        serializer: :json,
+        since: nil,
+        excluded: [],
+        complexity_validator: ComplexityValidator,
+        since_validator: Normal::SinceValidator,
+        **options
+      )
+        @language = language
+        @serializer = serializer
+        @since = since
+        @excluded = excluded
+        @complexity_validator = complexity_validator
+        @since_validator = since_validator
+        @options = options
+      end
+
+      def validate!
+        LanguageValidator.validate!(@language)
+        @since_validator.validate!(since: @since, relative_period: nil)
+        @complexity_validator.validate!(@language)
+      end
+
+      def checker
+        normal_config = Normal::Config.new(
+          language: @language,
+          serializer: :none,
+          since: @since,
+          excluded: @excluded,
+        )
+        Checker.new(engine: normal_config.checker, serializer: hotspots_serializer)
+      end
+
+      private
+
+      def hotspots_serializer
+        case @serializer
+        when :json then Serializer::Json
+        when :markdown then Serializer::Markdown
+        end
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/hotspots/serializer.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module ChurnVsComplexity
+  module Hotspots
+    module Serializer
+      module Json
+        def self.serialize(result)
+          entries = RiskAnnotator.annotate(result[:values_by_file])
+          entries.sort_by! { |e| -e[:gamma_score] }
+
+          JSON.generate({ generated: Time.now.utc.iso8601, files: entries,
+                          summary: RiskAnnotator.risk_summary(entries), })
+        end
+      end
+
+      module Markdown
+        RISK_HEADINGS = {
+          'high' => 'High Risk -- require tests and careful review',
+          'medium' => 'Medium Risk -- exercise judgement',
+          'low' => 'Low Risk -- safe for quick changes',
+        }.freeze
+
+        def self.serialize(result)
+          entries = RiskAnnotator.annotate(result[:values_by_file])
+          entries.sort_by! { |e| -e[:gamma_score] }
+          grouped = entries.group_by { |e| e[:risk] }
+
+          lines = ["## Hotspots (generated #{Date.today})", '']
+          RISK_HEADINGS.each { |level, heading| append_section(lines, grouped[level], heading) }
+          lines.join("\n")
+        end
+
+        def self.append_section(lines, entries, heading)
+          return unless entries&.any?
+
+          lines << "### #{heading}"
+          entries.each do |e|
+            lines << "- `#{e[:file]}` (gamma: #{e[:gamma_score]}, churn: #{e[:churn]}, complexity: #{e[:complexity]})"
+          end
+          lines << ''
+        end
+
+        private_class_method :append_section
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/hotspots.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'hotspots/serializer'
+require_relative 'hotspots/config'
+require_relative 'hotspots/checker'
+
+module ChurnVsComplexity
+  module Hotspots
+  end
+end