stud-finder 0.1.0 → 0.4.0

data/lib/stud_finder/cli.rb

@@ -17,6 +17,8 @@ require_relative 'fan_in'
 require_relative 'js_fan_in'
 require_relative 'js_complexity'
 require_relative 'file_collector'
+require_relative 'loc_counter'
+require_relative 'newness'
 require_relative 'scorer'
 require_relative 'version'
 
@@ -24,20 +26,23 @@ module StudFinder
   # rubocop:disable Metrics/ClassLength
   class CLI
     OUTPUT_FORMATS = %w[table json markdown csv].freeze
+    CLASS_RANK = { 'trunk' => 3, 'branch' => 2, 'leaf' => 1 }.freeze
     RESULT_COLUMNS = %w[
-      rank language file score class fan_in fan_in_pct fan_out fan_out_pct instability instability_pct complexity
-      complexity_pct churn_commits churn_lines churn_pct max_coupling max_coupling_partner coupling_partners
-      coupling_pct coverage
+      rank language file score evidence class new_file age_days escalation fan_in fan_in_pct fan_out fan_out_pct
+      instability instability_pct complexity complexity_pct churn_commits churn_lines churn_pct loc loc_pct max_coupling
+      max_coupling_partner coupling_partners coupling_pct coverage
     ].freeze
     MARKDOWN_COLUMNS = %w[
-      rank language file score class fan_in fan_out fan_out_pct instability complexity churn_commits churn_lines
-      churn_pct max_coupling max_coupling_partner coupling_partners coupling_pct coverage
+      rank language file score evidence class new_file age_days escalation fan_in fan_out fan_out_pct instability
+      complexity
+      churn_commits churn_lines churn_pct max_coupling max_coupling_partner coupling_partners coupling_pct coverage
     ].freeze
     WEIGHT_KEYS = %i[fan_in fan_out complexity churn coverage].freeze
+    OPTIONAL_WEIGHT_KEYS = %i[interaction coupling].freeze
     DEFAULT_OPTIONS = {
       output: 'table',
       churn_days: 180,
-      weights: { fan_in: 0.25, fan_out: 0.10, complexity: 0.25, churn: 0.25, coverage: 0.15 },
+      weights: StudFinder::Scorer::DEFAULT_WEIGHTS,
       custom_weights: false,
       trunk_threshold: 85,
       branch_threshold: 50,
@@ -48,15 +53,20 @@ module StudFinder
       ruby_coverage_path: nil,
       js_coverage_path: nil,
       js_timeout: 60,
+      rails_inference: true,
       diff_base: nil,
       only_paths: nil,
       filter_set: nil,
       coupling_threshold: 0.30,
       coupling_min_commits: 5,
+      coupling_max_commit_files: 50,
+      newness: true,
+      new_file_days: StudFinder::Newness::DEFAULT_DAYS,
+      new_file_min_commits: StudFinder::Newness::DEFAULT_MIN_COMMITS,
       cli_warnings: []
     }.freeze
 
-    Analysis = Struct.new(:files, :fan_in, :fan_out, :edges, :complexity, :churn_commits, :churn_lines, :coverage,
+    Analysis = Struct.new(:files, :fan_in, :fan_out, :edges, :complexity, :churn_commits, :churn_lines, :loc, :coverage,
                           :coverage_available, :skipped_files, :warnings, :rows, :weights, keyword_init: true)
     Report = Struct.new(:ruby, :javascript, :warnings, keyword_init: true)
 
@@ -112,7 +122,7 @@ module StudFinder
       0
     rescue OptionParser::InvalidOption, OptionParser::MissingArgument, OptionParser::InvalidArgument, ValidationError,
            FileCollector::Error, Churn::Error, Complexity::Error, Coverage::Cobertura::Error, Coverage::Detector::Error,
-           Coverage::Lcov::Error, Coverage::Resultset::Error, Diff::Error, Scorer::ValidationError => e
+           Coverage::Lcov::Error, Coverage::Resultset::Error, Diff::Error, Newness::Error, Scorer::ValidationError => e
       @stderr.puts e.message
       1
     end
@@ -132,7 +142,8 @@ module StudFinder
         files: result.files,
         days: @options[:churn_days],
         min_co_changes: @options[:coupling_min_commits],
-        coupling_threshold: @options[:coupling_threshold]
+        coupling_threshold: @options[:coupling_threshold],
+        max_commit_files: @options[:coupling_max_commit_files]
       ).call
 
       Edges.new(
@@ -143,7 +154,7 @@ module StudFinder
         coupling_threshold: @options[:coupling_threshold],
         stdout: @stdout, stderr: @stderr
       ).call
-    rescue FileCollector::Error, Churn::Error, Complexity::Error, Scorer::ValidationError => e
+    rescue FileCollector::Error, Churn::Error, Complexity::Error, Newness::Error, Scorer::ValidationError => e
       @stderr.puts e.message
       1
     end
@@ -164,10 +175,22 @@ module StudFinder
         opts.on('--churn-days N', Integer, 'Commit lookback window in days (default: 180)') do |value|
           @options[:churn_days] = value
         end
-        opts.on('--weights WEIGHTS', 'fan_in:F,fan_out:O,complexity:C,churn:H,coverage:V') do |value|
+        opts.on('--weights WEIGHTS',
+                'fan_in:F,fan_out:O,complexity:C,churn:H,coverage:V[,interaction:I][,coupling:P]') do |value|
           @options[:weights] = parse_weights(value)
           @options[:custom_weights] = true
         end
+        opts.on('--interaction-weight N', Float,
+                'fan_in × coverage_risk interaction weight (requires coverage)') do |value|
+          raise ValidationError, 'Error: weight values must be between 0.0 and 1.0.' if value.negative? || value > 1.0
+
+          @options[:weights][:interaction] = value
+        end
+        opts.on('--coupling-weight N', Float, 'temporal coupling weight') do |value|
+          raise ValidationError, 'Error: weight values must be between 0.0 and 1.0.' if value.negative? || value > 1.0
+
+          @options[:weights][:coupling] = value
+        end
         opts.on('--ruby-coverage PATH', 'Path to a Ruby coverage report (.xml, .info, .json)') do |value|
           @options[:ruby_coverage_path] = value
         end
@@ -182,12 +205,17 @@ module StudFinder
         opts.on('--js-timeout N', Integer, 'dependency-cruiser timeout in seconds (default: 60)') do |value|
           @options[:js_timeout] = value
         end
+        opts.on('--no-rails-inference', 'Disable Rails association/string fan-in inference') do
+          @options[:rails_inference] = false
+        end
         opts.on('--trunk-threshold N', Integer,
-                'fan_in percentile cutoff for trunk classification (default: 85)') do |value|
+                'score percentile cutoff for trunk classification, integer 1-99 ' \
+                '(default: 85 = top 15% of files by score)') do |value|
           @options[:trunk_threshold] = value
         end
         opts.on('--branch-threshold N', Integer,
-                'fan_in percentile cutoff for branch classification (default: 50)') do |value|
+                'score percentile cutoff for branch classification, integer 1-99 ' \
+                '(default: 50 = top 50% of files by score)') do |value|
           @options[:branch_threshold] = value
         end
         opts.on('--exclude PATTERN', 'Exclude glob pattern (repeatable)') do |value|
@@ -215,6 +243,22 @@ module StudFinder
                 'Minimum co-change count for edges output (default: 5)') do |value|
           @options[:coupling_min_commits] = value
         end
+        opts.on('--coupling-max-commit-files N', Integer,
+                'Skip temporal-coupling commits touching more than N files (default: 50, 0 = unlimited)') do |value|
+          @options[:coupling_max_commit_files] = value
+        end
+        opts.on('--new-file-days N', Integer,
+                'Treat files first committed within N days as new (default: 30, 0 disables age floor)') do |value|
+          @options[:new_file_days] = value
+        end
+        opts.on('--new-file-min-commits N', Integer,
+                'Treat files with fewer than N full-history commits as new ' \
+                '(default: 3, 0 disables count floor)') do |value|
+          @options[:new_file_min_commits] = value
+        end
+        opts.on('--no-newness', 'Disable new-file classification rules') do
+          @options[:newness] = false
+        end
         opts.on('--verbose', 'Print suppressed per-file warnings to stderr') do
           @options[:verbose] = true
         end
@@ -230,6 +274,7 @@ module StudFinder
     end
     # rubocop:enable Metrics/AbcSize, Metrics/BlockLength, Metrics/MethodLength
 
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
     def parse_weights(value)
       pairs = value.split(',').map do |entry|
         key, raw = entry.split(':', 2)
@@ -242,18 +287,23 @@ module StudFinder
 
       weights = pairs.to_h
       missing = WEIGHT_KEYS - weights.keys
-      extra = weights.keys - WEIGHT_KEYS
+      extra = weights.keys - WEIGHT_KEYS - OPTIONAL_WEIGHT_KEYS
       unless missing.empty? && extra.empty?
         raise ValidationError,
               'Error: weights must include fan_in, fan_out, complexity, churn, and coverage.'
       end
 
+      weights[:interaction] = 0.0 unless weights.key?(:interaction)
+      weights[:coupling] = 0.05 unless weights.key?(:coupling)
+
       out_of_range = weights.any? { |_key, weight| weight.negative? || weight > 1.0 }
       raise ValidationError, 'Error: weight values must be between 0.0 and 1.0.' if out_of_range
 
       weights
     end
 
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
     def validate_options!
       validate_threshold!(:trunk_threshold)
       validate_threshold!(:branch_threshold)
@@ -266,7 +316,12 @@ module StudFinder
       raise ValidationError, 'Error: --churn-days must be positive.' if @options[:churn_days] <= 0
       raise ValidationError, 'Error: --js-timeout must be positive.' if @options[:js_timeout] <= 0
 
+      validate_newness_options!
+
       raise ValidationError, 'Error: --coupling-min-commits must be positive.' if @options[:coupling_min_commits] <= 0
+      if @options[:coupling_max_commit_files].negative?
+        raise ValidationError, 'Error: --coupling-max-commit-files must be zero or positive.'
+      end
       unless (0.0..1.0).cover?(@options[:coupling_threshold])
         raise ValidationError, 'Error: --coupling-threshold must be between 0.0 and 1.0.'
       end
@@ -276,6 +331,13 @@ module StudFinder
       validate_weights! if @options[:custom_weights]
     end
 
+    def validate_newness_options!
+      raise ValidationError, 'Error: --new-file-days must be zero or positive.' if @options[:new_file_days].negative?
+      return unless @options[:new_file_min_commits].negative?
+
+      raise ValidationError, 'Error: --new-file-min-commits must be zero or positive.'
+    end
+
     def validate_coverage_paths!
       if @options[:ruby_coverage_path] && !File.file?(@options[:ruby_coverage_path])
         raise ValidationError, "Error: coverage file not found: #{@options[:ruby_coverage_path]}"
@@ -309,9 +371,15 @@ module StudFinder
 
     def validate_weights!
       weights = @options[:weights]
+      out_of_range = weights.any? { |_key, weight| !weight.nil? && (weight.negative? || weight > 1.0) }
+      raise ValidationError, 'Error: weight values must be between 0.0 and 1.0.' if out_of_range
+
       if weights[:coverage].positive? && !coverage_available?
         raise ValidationError, 'Error: coverage weight must be 0.0 when no coverage data is provided.'
       end
+      if weights.fetch(:interaction, 0.0).positive? && !coverage_available?
+        raise ValidationError, 'Error: interaction weight must be 0.0 when no coverage data is provided.'
+      end
 
       active_sum = weights.values.sum
       return if (active_sum - 1.0).abs <= 0.001
@@ -331,11 +399,24 @@ module StudFinder
         files: files,
         days: @options[:churn_days],
         min_co_changes: @options[:coupling_min_commits],
-        coupling_threshold: @options[:coupling_threshold]
+        coupling_threshold: @options[:coupling_threshold],
+        max_commit_files: @options[:coupling_max_commit_files]
       ).call
+      record_coupling_warnings(result.warnings)
       result.pairs.transform_values { |partners| aggregate_partners(partners) }
     end
 
+    def record_coupling_warnings(warnings)
+      @options[:cli_warnings].concat(warnings)
+      bulk_warning = warnings.find do |warning|
+        warning.is_a?(Hash) && warning[:code] == 'temporal_coupling_bulk_commits_skipped'
+      end
+      return unless @options[:verbose] && bulk_warning
+
+      @stderr.puts "Temporal coupling: skipped #{bulk_warning[:count]} bulk commits " \
+                   "(> #{bulk_warning[:max_commit_files]} files)."
+    end
+
     # Reduces a file's partner entries to its strongest-coupling partner.
     # Tie-break is deterministic: highest :coupling, then highest :co_changes,
     # then ascending alphabetical :path — so identical inputs always pick the same partner.
@@ -362,7 +443,8 @@ module StudFinder
 
     def analyze_ruby(path, files, coupling = nil)
       progress('computing Ruby fan_in + fan_out (rubocop-ast)...')
-      fan_in_result = FanIn.new(repo_path: path, files: files).call
+      fan_in_result = FanIn.new(repo_path: path, files: files, stderr: @stderr,
+                                rails_inference: @options[:rails_inference]).call
 
       progress('computing Ruby complexity (rubocop)...')
       complexity_result = Complexity.new(repo_path: path, files: files, stderr: @stderr).call
@@ -372,8 +454,9 @@ module StudFinder
       churn_result = Churn.new(repo_path: path, files: analysis_files, days: @options[:churn_days],
                                stderr: @stderr).call
 
+      loc = LocCounter.new(repo_path: path, files: analysis_files).call
       score_group(analysis_files, fan_in_result.counts, fan_in_result.fan_out_counts, fan_in_result.edges,
-                  complexity_result.counts, churn_result, complexity_result.skipped_files,
+                  complexity_result.counts, churn_result, loc, complexity_result.skipped_files,
                   ruby_coverage(path, analysis_files),
                   language_by_file: analysis_files.to_h { |file| [file, :ruby] }, coupling: coupling)
     end
@@ -386,19 +469,21 @@ module StudFinder
       complexity_result = JsComplexity.new(repo_path: path, files: files, js_timeout: @options[:js_timeout],
                                            stderr: @stderr).call
       churn_result = Churn.new(repo_path: path, files: files, days: @options[:churn_days], stderr: @stderr).call
+      loc = LocCounter.new(repo_path: path, files: files).call
       score_group(files, fan_in_result.counts, fan_in_result.fan_out_counts, fan_in_result.edges,
-                  complexity_result.counts, churn_result, [], js_coverage(path, files),
+                  complexity_result.counts, churn_result, loc, [], js_coverage(path, files),
                   language_by_file: languages, extra_warnings: fan_in_result.warnings + complexity_result.warnings,
                   coupling: coupling)
     end
 
     # rubocop:disable Metrics/ParameterLists
-    def score_group(files, fan_in, fan_out, edges, complexity, churn_result, skipped_files, coverage_payload,
+    def score_group(files, fan_in, fan_out, edges, complexity, churn_result, loc, skipped_files, coverage_payload,
                     language_by_file: {}, extra_warnings: [], coupling: nil)
       progress("normalizing + scoring #{files.length} files...")
       coverage_result, coverage_parser = coverage_payload
+      loc_pct = loc_percentiles_by_language(files, loc, language_by_file)
       scorer = Scorer.new(files: files, fan_in: fan_in, fan_out: fan_out, complexity: complexity,
-                          churn: churn_result.counts, churn_lines: churn_result.line_counts,
+                          churn: churn_result.counts, churn_lines: churn_result.line_counts, loc: loc, loc_pct: loc_pct,
                           coverage: coverage_result, weights: @options[:weights],
                           branch_threshold: @options[:branch_threshold], trunk_threshold: @options[:trunk_threshold],
                           coupling: coupling)
@@ -409,16 +494,40 @@ module StudFinder
       warnings << 'files_skipped' if skipped_files.any?
       warnings << 'small_repo' if files.length < @options[:min_files]
       emit_scoring_note(scorer, coverage_result)
+      scored_rows = scorer.call
+      warnings.concat(scorer.warnings)
+      rows = apply_newness(files, edges, scored_rows, coverage_result)
+             .map { |row| with_language(row, language_by_file) }
+      rows = sort_and_rank_rows(rows, files)
       Analysis.new(
         files: files, fan_in: fan_in, fan_out: fan_out, edges: edges, complexity: complexity,
-        churn_commits: churn_result.churn_commits, churn_lines: churn_result.churn_lines,
+        churn_commits: churn_result.churn_commits, churn_lines: churn_result.churn_lines, loc: loc,
         coverage: coverage_result, coverage_available: !coverage_result.nil?, skipped_files: skipped_files,
-        warnings: warnings.uniq, rows: scorer.call.map { |row| with_language(row, language_by_file) },
+        warnings: warnings.uniq, rows: rows,
         weights: scorer.normalized_weights
       )
     end
     # rubocop:enable Metrics/ParameterLists
 
+    def apply_newness(files, edges, rows, coverage_result = nil)
+      metadata = if @options[:newness] && Newness.shallow_repository?(@repo_path)
+                   @options[:cli_warnings] << Newness::SHALLOW_CLONE_WARNING
+                   Newness.disabled_metadata(files)
+                 elsif @options[:newness]
+                   Newness.new(repo_path: @repo_path, files: files, days: @options[:new_file_days],
+                               min_commits: @options[:new_file_min_commits]).call
+                 else
+                   Newness.disabled_metadata(files)
+                 end
+      Newness.apply(rows: rows, edges: edges, metadata: metadata, coverage: coverage_result)
+    end
+
+    def loc_percentiles_by_language(files, loc, language_by_file)
+      files.group_by { |file| language_by_file.fetch(file) }.values.reduce({}) do |pct, language_files|
+        pct.merge(Normalizer.percentile_rank(loc, language_files))
+      end
+    end
+
     def with_language(row, language_by_file)
       row.merge(language: language_by_file.fetch(row[:path]).to_s)
     end
@@ -439,7 +548,7 @@ module StudFinder
 
     def emit_scoring_note(scorer, coverage_result)
       if coverage_result
-        @stderr.puts 'Note: coverage data available. Score uses 5-factor formula.'
+        @stderr.puts coverage_scoring_note(weights: scorer.normalized_weights)
       else
         @stderr.puts scoring_note(weights: scorer.normalized_weights, stderr: true)
       end
@@ -525,6 +634,14 @@ module StudFinder
                  warnings: (analysis.warnings + ['diff_no_scored_files']).uniq)
     end
 
+    def sort_and_rank_rows(rows, files)
+      original_index = files.each_with_index.to_h
+      sorted = rows.sort_by do |row|
+        [-CLASS_RANK.fetch(row[:classification], 0), -row[:score], original_index.fetch(row[:path])]
+      end
+      sorted.map.with_index(1) { |row, rank| row.merge(rank: rank) }
+    end
+
     def limited_rows(rows)
       filtered = @options[:filter_set] ? rows.select { |row| @options[:filter_set].include?(row[:path]) } : rows
       @options[:top] ? filtered.first(@options[:top]) : filtered
@@ -541,8 +658,10 @@ module StudFinder
     end
 
     def empty_analysis
-      Analysis.new(files: [], fan_in: {}, fan_out: {}, edges: {}, complexity: {}, churn_commits: {}, churn_lines: {},
-                   coverage: nil, coverage_available: false, skipped_files: [], warnings: [], rows: [], weights: nil)
+      Analysis.new(
+        files: [], fan_in: {}, fan_out: {}, edges: {}, complexity: {}, churn_commits: {}, churn_lines: {}, loc: {},
+        coverage: nil, coverage_available: false, skipped_files: [], warnings: [], rows: [], weights: nil
+      )
     end
 
     def emit_markdown_section(title, rows)
@@ -556,9 +675,12 @@ module StudFinder
 
     def emit_table_section(title, rows)
       @stdout.puts title
-      @stdout.puts ' rank  language    file                                            score  class   fan_in  ' \
-                   'fan_out  instability  complexity  churn_commits  churn_lines  churn_pct  max_coupling  ' \
-                   'max_coupling_partner                      coupling_partners  coupling_pct  coverage'
+      @stdout.puts ' rank  language    file                                            score  evidence  class   new  ' \
+                   'age_days  ' \
+                   'escalation      fan_in  fan_out  instability  complexity  churn_commits  churn_lines  ' \
+                   'churn_pct    loc  loc_pct  ' \
+                   'max_coupling  max_coupling_partner                      coupling_partners  coupling_pct  ' \
+                   'coverage'
       rows.each { |row| @stdout.puts table_row(row) }
       @stdout.puts
     end
@@ -586,7 +708,7 @@ module StudFinder
         churn_days: @options[:churn_days],
         file_count: analysis.ruby.files.length + analysis.javascript.files.length,
         files_skipped: analysis.ruby.skipped_files.length + analysis.javascript.skipped_files.length,
-        formula: report_coverage_available?(analysis) ? '5-factor' : '4-factor (no coverage)',
+        formula: json_formula(analysis),
         weights: json_weights(analysis.ruby.weights || analysis.javascript.weights),
         warnings: analysis.warnings
       }
@@ -600,8 +722,10 @@ module StudFinder
       @stdout.puts "## stud-finder — #{Time.now.utc.strftime('%Y-%m-%d')}"
       @stdout.puts
       file_count = analysis.ruby.files.length + analysis.javascript.files.length
-      @stdout.puts "> #{report_coverage_available?(analysis) ? '5-factor score' : '4-factor score (no coverage)'}. " \
-                   "Churn window: #{@options[:churn_days]} days. #{file_count} files analyzed."
+      weights = analysis.ruby.weights || analysis.javascript.weights
+      md_formula = formula_label(coverage_available: report_coverage_available?(analysis),
+                                 coupling_available: weights[:coupling])
+      @stdout.puts "> #{md_formula}. Churn window: #{@options[:churn_days]} days. #{file_count} files analyzed."
       note = filter_note
       if note
         @stdout.puts
@@ -615,18 +739,20 @@ module StudFinder
 
     def markdown_row(row)
       values = [
-        row[:rank], row[:language], row[:path], format_score(row[:score]), row[:classification], row[:fan_in],
-        row[:fan_out], format_score(row[:fan_out_pct]), format_score(row[:instability]), row[:complexity],
-        row[:churn_commits], row[:churn_lines], format_score(row[:churn_pct]), format_score(row[:max_coupling]),
-        row[:max_coupling_partner], row[:coupling_partners], format_score(row[:coupling_pct]),
-        format_coverage(row[:coverage])
+        row[:rank], row[:language], row[:path], format_score(row[:score]), format_evidence(row[:evidence]),
+        row[:classification], row[:new_file], row[:age_days], row[:escalation], row[:fan_in], row[:fan_out],
+        format_score(row[:fan_out_pct]),
+        format_score(row[:instability]), row[:complexity], row[:churn_commits], row[:churn_lines],
+        format_score(row[:churn_pct]), format_score(row[:max_coupling]), row[:max_coupling_partner],
+        row[:coupling_partners], format_score(row[:coupling_pct]), format_coverage(row[:coverage])
       ]
       "| #{values.join(' | ')} |"
     end
 
     def emit_table(path, result, analysis, ruby_rows, javascript_rows)
       coverage_available = report_coverage_available?(analysis)
-      formula = coverage_available ? '5-factor score' : '4-factor score'
+      weights = analysis.ruby.weights || analysis.javascript.weights
+      formula = formula_label(coverage_available: coverage_available, coupling_available: weights[:coupling])
       @stdout.puts "stud-finder — #{path} (#{@options[:churn_days]}-day churn, #{formula})"
       unless coverage_available
         @stdout.puts scoring_note(weights: analysis.ruby.weights || analysis.javascript.weights,
@@ -649,7 +775,11 @@ module StudFinder
         language: row[:language],
         path: row[:path],
         score: row[:score],
+        evidence: row[:evidence],
         class: row[:classification],
+        new_file: row[:new_file],
+        age_days: row[:age_days],
+        escalation: row[:escalation],
         fan_in: row[:fan_in],
         fan_in_pct: row[:fan_in_pct],
         fan_out: row[:fan_out],
@@ -661,6 +791,8 @@ module StudFinder
         churn_commits: row[:churn_commits],
         churn_lines: row[:churn_lines],
         churn_pct: row[:churn_pct],
+        loc: row[:loc],
+        loc_pct: row[:loc_pct],
         max_coupling: row[:max_coupling],
         max_coupling_partner: row[:max_coupling_partner],
         coupling_partners: row[:coupling_partners],
@@ -675,7 +807,11 @@ module StudFinder
         row[:language],
         row[:path],
         format_score(row[:score]),
+        format_evidence(row[:evidence]),
         row[:classification],
+        row[:new_file],
+        row[:age_days],
+        row[:escalation],
         row[:fan_in],
         format_score(row[:fan_in_pct]),
         row[:fan_out],
@@ -687,6 +823,8 @@ module StudFinder
         row[:churn_commits],
         row[:churn_lines],
         format_score(row[:churn_pct]),
+        row[:loc],
+        format_score(row[:loc_pct]),
         format_score(row[:max_coupling]),
         row[:max_coupling_partner],
         row[:coupling_partners],
@@ -699,19 +837,53 @@ module StudFinder
       analysis.ruby.coverage_available || analysis.javascript.coverage_available
     end
 
+    def json_formula(analysis)
+      weights = analysis.ruby.weights || analysis.javascript.weights
+      formula_label(
+        coverage_available: report_coverage_available?(analysis),
+        coupling_available: weights[:coupling]
+      )
+    end
+
+    def formula_label(coverage_available:, coupling_available:)
+      coupling = coupling_available.to_f.positive?
+      if coverage_available
+        coupling ? '5-factor + coupling' : '5-factor'
+      else
+        coupling ? '4-factor + coupling' : '4-factor'
+      end
+    end
+
     def json_weights(weights)
       {
         fan_in: weights[:fan_in].round(4),
         fan_out: weights[:fan_out].round(4),
         complexity: weights[:complexity].round(4),
         churn: weights[:churn].round(4),
-        coverage: weights[:coverage]&.round(4)
+        coverage: weights[:coverage]&.round(4),
+        interaction: weights[:interaction]&.round(4),
+        coupling: weights[:coupling]&.round(4)
       }
     end
 
+    def coverage_scoring_note(weights:)
+      label = formula_label(coverage_available: true, coupling_available: weights[:coupling])
+      "Note: coverage data available. Score uses #{label} formula."
+    end
+
     def scoring_note(weights:, stderr:)
-      if stderr
-        format('Note: coverage data not available. Score uses 4-factor formula (fan_in %<fan_in>.2f, ' \
+      label = formula_label(coverage_available: false, coupling_available: weights[:coupling])
+      if weights[:coupling]
+        if stderr
+          format("Note: coverage data not available. Score uses #{label} formula (fan_in %<fan_in>.2f, " \
+                 'fan_out %<fan_out>.2f, complexity %<complexity>.2f, churn %<churn>.2f, ' \
+                 'coupling %<coupling>.2f).', **weights)
+        else
+          format('Note: coverage data not available. Score uses fan_in %<fan_in>.2f, fan_out %<fan_out>.2f, ' \
+                 'complexity %<complexity>.2f, churn %<churn>.2f, coupling %<coupling>.2f.', **weights)
+        end
+      elsif stderr
+        format("Note: coverage data not available. Score uses #{label} formula (fan_in %<fan_in>.2f, " \
                'fan_out %<fan_out>.2f, complexity %<complexity>.2f, churn %<churn>.2f).', **weights)
       else
         format('Note: coverage data not available. Score uses fan_in %<fan_in>.2f, fan_out %<fan_out>.2f, ' \
@@ -739,19 +911,33 @@ module StudFinder
     def format_coverage(coverage)
       return 'n/a' if coverage.nil?
 
+      return coverage if coverage.is_a?(String)
+
       "#{(coverage * 100).round}%"
     end
 
+    def format_evidence(evidence)
+      return nil if evidence.nil?
+
+      format_score(evidence)
+    end
+
     def table_row(row)
-      format('%<rank>5d  %<language>-10s  %<path>-45s  %<score>6s  %<classification>-6s  %<fan_in>6d  ' \
-             '%<fan_out>7d  %<instability>11s  %<complexity>10d  %<churn_commits>13d  %<churn_lines>11d  ' \
-             '%<churn_pct>9s  %<max_coupling>12s  %<max_coupling_partner>-40s  %<coupling_partners>17d  ' \
+      format('%<rank>5d  %<language>-10s  %<path>-45s  %<score>6s  %<evidence>8s  ' \
+             '%<classification>-6s  %<new_file>5s  ' \
+             '%<age_days>8d  %<escalation>-15s  %<fan_in>6d  %<fan_out>7d  %<instability>11s  %<complexity>10d  ' \
+             '%<churn_commits>13d  %<churn_lines>11d  %<churn_pct>9s  %<loc>5d  %<loc_pct>7s  ' \
+             '%<max_coupling>12s  %<max_coupling_partner>-40s  %<coupling_partners>17d  ' \
              '%<coupling_pct>12s  %<coverage>8s',
              rank: row[:rank], language: row[:language], path: row[:path], score: format_score(row[:score]),
-             classification: row[:classification], fan_in: row[:fan_in], fan_out: row[:fan_out],
-             instability: format_score(row[:instability]), complexity: row[:complexity],
+             evidence: format_evidence(row[:evidence]) || 'n/a', classification: row[:classification],
+             new_file: row[:new_file].to_s, age_days: row[:age_days].to_i,
+             escalation: row[:escalation],
+             fan_in: row[:fan_in], fan_out: row[:fan_out], instability: format_score(row[:instability]),
+             complexity: row[:complexity],
              churn_commits: row[:churn_commits], churn_lines: row[:churn_lines],
-             churn_pct: format_score(row[:churn_pct]), max_coupling: format_score(row[:max_coupling]),
+             churn_pct: format_score(row[:churn_pct]), loc: row[:loc], loc_pct: format_score(row[:loc_pct]),
+             max_coupling: format_score(row[:max_coupling]),
              max_coupling_partner: truncate_partner(row[:max_coupling_partner]),
              coupling_partners: row[:coupling_partners], coupling_pct: format_score(row[:coupling_pct]),
              coverage: format_coverage(row[:coverage]))