churn_vs_complexity 1.6.1 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6dfa844a5bcd2fe116001652410d39f802c64623be5ec588afcc6ed331b9aac9
-  data.tar.gz: 42c5d56c7b4c6640bd4040f7f5d8b35ea6acac0aae9285be4c6cb1aaf860f0fb
+  metadata.gz: dbfecd03ad25cb8f79ae5b52564f591b122eab2b8ee13e3fe80d1d33883e2747
+  data.tar.gz: 4ba6ffb8794bb11c9e87103f26b481b9b6bb29230eb1c55fa7fff7c46aaa0687
 SHA512:
-  metadata.gz: 0ad833af0897a784aa0499d277884e011e9be71142d343c441ef0a12b1185c27f18c09b0b7780a3f8493e3ef0399faff5f97b252f51fb4713f3dd98d11b666a7
-  data.tar.gz: 19cf09a9777aa06a4772fae21fee5a4043ba034efde9d2af13618461b20a602270879438c4aa626463c3ea14054bf1dc8a7b9a25cde09c9636439d9d567a30f3
+  metadata.gz: c7463ac718037f9f8d13ba08d1c39b775557246f85bd3e29852ee573b1af55625026e792d239e3d38df118923f80b68d75243508f5dd98b6739bd1b80408fe20
+  data.tar.gz: 35358bac1704bc9bca9cb9204d053c3484d9aa5e4d1e378b0feb48e2236f014354494b8ddcd36d12d127865361add543f511e514bfa412d01f7b34f038fb1042

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+## [1.7.0] - 2026-04-05
+
+### Added
+- Kotlin support for complexity calculation (via [lizard](https://github.com/terryyin/lizard), install with `pip install lizard`)
+
+## [1.6.2] - 2026-02-19
+
+### Changed
+- Risk classification in triage, hotspots, and focus modes is now language-aware
+- Ruby thresholds raised to low=30/high=70 (Flog scores 3-7x higher than cyclomatic tools)
+- Go thresholds raised to low=15/high=40 (cognitive complexity penalises nesting)
+- Java, Python, and JavaScript/TypeScript thresholds unchanged (low=10/high=25)
+
 ## [1.6.1] - 2026-02-19
 
 ### Changed

data/CLAUDE.md

@@ -4,7 +4,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## Project Overview
 
-`churn_vs_complexity` is a Ruby gem that analyzes code quality by correlating file churn (how often files change) with complexity scores. It supports Ruby (via Flog), JavaScript/TypeScript (via ESLint), and Java (via PMD). Requires Ruby >= 3.3.
+`churn_vs_complexity` is a Ruby gem that analyzes code quality by correlating file churn (how often files change) with complexity scores. It supports Ruby (via Flog), JavaScript/TypeScript (via ESLint), Java (via PMD), Python (via Radon), Go (via gocognit), and Kotlin (via lizard). Requires Ruby >= 3.3.
 
 ## Commands
 

data/README.md

@@ -2,7 +2,7 @@
 
 # ChurnVsComplexity
 
-Correlates file churn (how often files change) with complexity scores to identify refactoring hotspots and track codebase health over time. Supports Ruby, JavaScript/TypeScript, Java, Python, and Go.
+Correlates file churn (how often files change) with complexity scores to identify refactoring hotspots and track codebase health over time. Supports Ruby, JavaScript/TypeScript, Java, Python, Go, and Kotlin.
 
 Modes include hotspots ranking, triage assessment, CI quality gate, diff comparison, focus sessions, and timetravel history.
 
@@ -33,6 +33,7 @@ External tool dependencies per language:
 - **JavaScript/TypeScript**: Requires [Node.js](https://nodejs.org) (uses ESLint internally).
 - **Python**: Requires [Radon](https://radon.readthedocs.io) on the search path as `radon`. Install with `pip install radon`.
 - **Go**: Requires [gocyclo](https://github.com/fzipp/gocyclo) on the search path. Install with `go install github.com/fzipp/gocyclo/cmd/gocyclo@latest`.
+- **Kotlin**: Requires [lizard](https://github.com/terryyin/lizard) on the search path. Install with `pip install lizard`.
 
 ## Usage
 
@@ -48,6 +49,7 @@ Languages:
                                      Check complexity of javascript and typescript files
         --python                     Check complexity of python files
         --go                         Check complexity of go files
+        --kotlin                     Check complexity of kotlin files
 
 Modes (mutually exclusive):
         --timetravel N               Calculate summary for all commits at intervals of N days throughout project history or from the date specified with --since
@@ -121,6 +123,9 @@ churn_vs_complexity --java -m --since 2019-03-01 --timetravel 30 --graph my_java
 
 # Analyse complexity of specific commits
 churn_vs_complexity --js --delta HEAD --summary my_js_project
+
+# Kotlin project hotspots
+churn_vs_complexity --kotlin --hotspots my_kotlin_project
 ```
 
 ## Development

data/lib/churn_vs_complexity/cli/parser.rb

@@ -34,6 +34,10 @@ module ChurnVsComplexity
             options[:language] = :go
           end
 
+          opts.on('--kotlin', 'Check complexity of kotlin files') do
+            options[:language] = :kotlin
+          end
+
           opts.separator ''
           opts.separator 'Modes (mutually exclusive):'
 

data/lib/churn_vs_complexity/complexity/kotlin_calculator.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module ChurnVsComplexity
+  module Complexity
+    module KotlinCalculator
+      class << self
+        attr_writer :command_runner
+
+        def folder_based? = false
+
+        def calculate(files:)
+          csv_output = run_lizard(files)
+          parse_lizard_output(csv_output, files:)
+        end
+
+        # Lizard CSV format: NLOC,CCN,tokens,params,length,"loc","file","func","long_func",start,end
+        LIZARD_LINE_PATTERN = /^\d+,(\d+),\d+,\d+,\d+,"[^"]*","([^"]*)"/.freeze
+
+        def parse_lizard_output(csv_output, files:)
+          scores = Hash.new(0)
+          csv_output.each_line do |line|
+            match = line.match(LIZARD_LINE_PATTERN)
+            next unless match
+
+            scores[match[2]] += match[1].to_i
+          end
+          files.to_h { |file| [file, scores[file] || 0] }
+        end
+
+        def check_dependencies!
+          command_runner.call('lizard --version 2>&1')
+        rescue Errno::ENOENT
+          raise Error, 'Needs lizard installed (pip install lizard)'
+        end
+
+        private
+
+        def command_runner
+          @command_runner || Open3.method(:capture2)
+        end
+
+        def run_lizard(files)
+          files_arg = files.map { |f| "'#{f}'" }.join(' ')
+          stdout, status = command_runner.call("lizard --csv #{files_arg}")
+          raise Error, "lizard failed (exit #{status.exitstatus}). Is it installed?" unless status.success?
+
+          stdout
+        end
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/complexity.rb

@@ -5,6 +5,7 @@ require_relative 'complexity/flog_calculator'
 require_relative 'complexity/eslint_calculator'
 require_relative 'complexity/python_calculator'
 require_relative 'complexity/go_calculator'
+require_relative 'complexity/kotlin_calculator'
 
 module ChurnVsComplexity
   module Complexity

data/lib/churn_vs_complexity/complexity_validator.rb

@@ -12,6 +12,8 @@ module ChurnVsComplexity
         Complexity::PythonCalculator.check_dependencies!
       when :go
         Complexity::GoCalculator.check_dependencies!
+      when :kotlin
+        Complexity::KotlinCalculator.check_dependencies!
       end
     end
   end

data/lib/churn_vs_complexity/delta.rb

@@ -38,6 +38,8 @@ module ChurnVsComplexity
           FileSelector::Python.predefined(included:, excluded:)
         when :go
           FileSelector::Go.predefined(included:, excluded:)
+        when :kotlin
+          FileSelector::Kotlin.predefined(included:, excluded:)
         end
       end
 
@@ -53,6 +55,8 @@ module ChurnVsComplexity
           Complexity::PythonCalculator
         when :go
           Complexity::GoCalculator
+        when :kotlin
+          Complexity::KotlinCalculator
         end
       end
     end

data/lib/churn_vs_complexity/file_selector.rb

@@ -14,6 +14,8 @@ module ChurnVsComplexity
         ['.py']
       when :go
         ['.go']
+      when :kotlin
+        ['.kt', '.kts']
       else
         raise Error, "Unsupported language: #{language}"
       end
@@ -130,5 +132,15 @@ module ChurnVsComplexity
         Predefined.new(included:, extensions: FileSelector.extensions(:go), excluded:)
       end
     end
+
+    module Kotlin
+      def self.excluding(excluded)
+        Excluding.new(FileSelector.extensions(:kotlin), excluded)
+      end
+
+      def self.predefined(included:, excluded:)
+        Predefined.new(included:, extensions: FileSelector.extensions(:kotlin), excluded:)
+      end
+    end
   end
 end

data/lib/churn_vs_complexity/focus/checker.rb

@@ -5,11 +5,12 @@ require 'json'
 module ChurnVsComplexity
   module Focus
     class Checker
-      def initialize(engine:, subcommand:, serializer:, baseline_path:)
+      def initialize(engine:, subcommand:, serializer:, baseline_path:, language: nil)
         @engine = engine
         @subcommand = subcommand
         @serializer = serializer
         @baseline_path = baseline_path
+        @language = language
       end
 
       def check(folder:)
@@ -24,7 +25,7 @@ module ChurnVsComplexity
 
       def run_start(folder, baseline_path)
         raw_result = @engine.check(folder:)
-        entries = RiskAnnotator.annotate(raw_result[:values_by_file])
+        entries = RiskAnnotator.annotate(raw_result[:values_by_file], language: @language)
 
         baseline = {
           timestamp: Time.now.utc.iso8601,
@@ -37,7 +38,7 @@ module ChurnVsComplexity
 
       def run_end(folder, baseline_path)
         raw_result = @engine.check(folder:)
-        current_entries = RiskAnnotator.annotate(raw_result[:values_by_file])
+        current_entries = RiskAnnotator.annotate(raw_result[:values_by_file], language: @language)
 
         baseline = load_baseline(baseline_path)
         @serializer.serialize(baseline:, current: current_entries)

data/lib/churn_vs_complexity/focus/config.rb

@@ -40,6 +40,7 @@ module ChurnVsComplexity
           subcommand: @subcommand,
           serializer: focus_serializer,
           baseline_path: @baseline_path,
+          language: @language,
         )
       end
 

data/lib/churn_vs_complexity/hotspots/checker.rb

@@ -3,14 +3,15 @@
 module ChurnVsComplexity
   module Hotspots
     class Checker
-      def initialize(engine:, serializer:)
+      def initialize(engine:, serializer:, language: nil)
         @engine = engine
         @serializer = serializer
+        @language = language
       end
 
       def check(folder:)
         raw_result = @engine.check(folder:)
-        @serializer.serialize(raw_result)
+        @serializer.serialize(raw_result.merge(language: @language))
       end
     end
   end

data/lib/churn_vs_complexity/hotspots/config.rb

@@ -34,7 +34,7 @@ module ChurnVsComplexity
           since: @since,
           excluded: @excluded,
         )
-        Checker.new(engine: normal_config.checker, serializer: hotspots_serializer)
+        Checker.new(engine: normal_config.checker, serializer: hotspots_serializer, language: @language)
       end
 
       private

data/lib/churn_vs_complexity/hotspots/serializer.rb

@@ -7,7 +7,7 @@ module ChurnVsComplexity
     module Serializer
       module Json
         def self.serialize(result)
-          entries = RiskAnnotator.annotate(result[:values_by_file])
+          entries = RiskAnnotator.annotate(result[:values_by_file], language: result[:language])
           entries.sort_by! { |e| -e[:gamma_score] }
 
           JSON.generate({ generated: Time.now.utc.iso8601, files: entries,
@@ -23,7 +23,7 @@ module ChurnVsComplexity
         }.freeze
 
         def self.serialize(result)
-          entries = RiskAnnotator.annotate(result[:values_by_file])
+          entries = RiskAnnotator.annotate(result[:values_by_file], language: result[:language])
           entries.sort_by! { |e| -e[:gamma_score] }
           grouped = entries.group_by { |e| e[:risk] }
 

data/lib/churn_vs_complexity/language_validator.rb

@@ -2,7 +2,7 @@
 
 module ChurnVsComplexity
   module LanguageValidator
-    SUPPORTED = %i[java ruby javascript python go].freeze
+    SUPPORTED = %i[java ruby javascript python go kotlin].freeze
 
     def self.validate!(language)
       raise ValidationError, "Unsupported language: #{language}" unless SUPPORTED.include?(language)

data/lib/churn_vs_complexity/normal/config.rb

@@ -75,6 +75,14 @@ module ChurnVsComplexity
             serializer:,
             since: @since || @relative_period,
           )
+        when :kotlin
+          Engine.concurrent(
+            complexity: Complexity::KotlinCalculator,
+            churn:,
+            file_selector: FileSelector::Kotlin.excluding(@excluded),
+            serializer:,
+            since: @since || @relative_period,
+          )
         end
       end
 

data/lib/churn_vs_complexity/risk_annotator.rb

@@ -2,7 +2,7 @@
 
 module ChurnVsComplexity
   module RiskAnnotator
-    def self.annotate(values_by_file, classifier: RiskClassifier.new)
+    def self.annotate(values_by_file, language: nil, classifier: RiskClassifier.new(language: language))
       values_by_file.map { |file, values| build_entry(file, values, classifier) }
     end
 

data/lib/churn_vs_complexity/risk_classifier.rb

@@ -1,19 +1,44 @@
 # frozen_string_literal: true
 
 module ChurnVsComplexity
+  # Classifies files into low/medium/high risk based on gamma score
+  # (harmonic mean of churn and complexity).
+  #
+  # IMPORTANT: Complexity scores are NOT comparable across languages.
+  # Each language uses a different tool with a different numeric scale.
+  # All tools sum per-function scores across the file, but the magnitude differs:
+  #
+  #   Language       Tool      Metric                Trivial  Complex (~100 LOC)  Real-world range
+  #   Ruby           Flog      Code pain (weighted)  0        ~286                0-88
+  #   JavaScript/TS  ESLint    Cyclomatic complexity  3        ~62                 10-50
+  #   Python         Radon     Cyclomatic complexity  1        ~44                 5-50
+  #   Java           PMD       Cyclomatic complexity  1        ~39                 1-40
+  #   Go             gocognit  Cognitive complexity   0        ~87                 0-50
+  #   Kotlin         lizard    Cyclomatic complexity  1        ~40                 1-40
+  #
+  # The DEFAULT_LOW and DEFAULT_HIGH thresholds below are rough midpoints
+  # suitable for Java/Python/JS. They are too aggressive for Ruby (Flog
+  # scores 3-7x higher) and Go (cognitive complexity penalises nesting).
+  # Use the constructor to pass language-appropriate thresholds.
   class RiskClassifier
     DEFAULT_LOW = 10
     DEFAULT_HIGH = 25
 
+    LANGUAGE_DEFAULTS = {
+      ruby: { low: 30, high: 70 },
+      go: { low: 15, high: 40 },
+    }.freeze
+
     RECOMMENDATIONS = {
       'low' => 'Safe for quick changes.',
       'medium' => 'Exercise judgement; consider tests for non-trivial changes.',
       'high' => 'Write tests before modifying. Consider multi-agent review.',
     }.freeze
 
-    def initialize(low: DEFAULT_LOW, high: DEFAULT_HIGH)
-      @low = low
-      @high = high
+    def initialize(low: DEFAULT_LOW, high: DEFAULT_HIGH, language: nil)
+      defaults = LANGUAGE_DEFAULTS.fetch(language, {})
+      @low = defaults.fetch(:low, low)
+      @high = defaults.fetch(:high, high)
     end
 
     def classify(gamma_score:)

data/lib/churn_vs_complexity/triage/checker.rb

@@ -16,7 +16,7 @@ module ChurnVsComplexity
         folder = folder || dirs.first || '.'
         engine = build_engine(files, folder)
         raw_result = engine.check(folder:)
-        @serializer.serialize(raw_result)
+        @serializer.serialize(raw_result.merge(language: @language))
       end
 
       private

data/lib/churn_vs_complexity/triage/serializer.rb

@@ -7,7 +7,7 @@ module ChurnVsComplexity
     module Serializer
       module Json
         def self.serialize(result)
-          entries = RiskAnnotator.annotate(result[:values_by_file])
+          entries = RiskAnnotator.annotate(result[:values_by_file], language: result[:language])
           JSON.generate({ files: entries, summary: RiskAnnotator.risk_summary(entries) })
         end
       end

data/lib/churn_vs_complexity/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ChurnVsComplexity
-  VERSION = '1.6.1'
+  VERSION = '1.7.0'
 end

data/tmp/test-support/kotlin/Main.kt

@@ -0,0 +1,7 @@
+fun main() {
+    println("Hello, world!")
+}
+
+fun add(a: Int, b: Int): Int {
+    return a + b
+}

data/tmp/test-support/kotlin/Utils.kt

@@ -0,0 +1,11 @@
+fun calculateSum(numbers: List<Int>): Int {
+    var total = 0
+    for (n in numbers) {
+        total += n
+    }
+    return total
+}
+
+fun isEven(n: Int): Boolean {
+    return n % 2 == 0
+}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: churn_vs_complexity
 version: !ruby/object:Gem::Version
-  version: 1.6.1
+  version: 1.7.0
 platform: ruby
 authors:
 - Erik T. Madsen
@@ -39,8 +39,8 @@ dependencies:
         version: '2.1'
 description: Correlates file churn (how often files change) with complexity scores
   to identify refactoring hotspots. Supports Ruby, JavaScript/TypeScript, Java, Python,
-  and Go. Modes include hotspots ranking, triage assessment, CI quality gate, diff
-  comparison, focus sessions, and timetravel history. Inspired by Michael Feathers'
+  Go, and Kotlin. Modes include hotspots ranking, triage assessment, CI quality gate,
+  diff comparison, focus sessions, and timetravel history. Inspired by Michael Feathers'
   article "Getting Empirical about Refactoring".
 email:
 - beatmadsen@gmail.com
@@ -69,6 +69,7 @@ files:
 - lib/churn_vs_complexity/complexity/eslint_calculator.rb
 - lib/churn_vs_complexity/complexity/flog_calculator.rb
 - lib/churn_vs_complexity/complexity/go_calculator.rb
+- lib/churn_vs_complexity/complexity/kotlin_calculator.rb
 - lib/churn_vs_complexity/complexity/pmd.rb
 - lib/churn_vs_complexity/complexity/pmd/files_calculator.rb
 - lib/churn_vs_complexity/complexity/pmd/folder_calculator.rb
@@ -145,6 +146,8 @@ files:
 - tmp/test-support/javascript/moderate.js
 - tmp/test-support/javascript/simple.js
 - tmp/test-support/javascript/typescript-example.ts
+- tmp/test-support/kotlin/Main.kt
+- tmp/test-support/kotlin/Utils.kt
 - tmp/test-support/python/example.py
 - tmp/test-support/python/utils.py
 - tmp/test-support/txt/abc.txt
@@ -179,7 +182,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Analyse churn vs complexity to find refactoring hotspots, gate CI quality,
   triage risky files, and track codebase health over time.