predictability-engine 0.6.6

data/lib/predictability_engine/setup_manager.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'bundler'
+
+module PredictabilityEngine
+  class SetupManager
+    NODE_MIN_MAJOR = 18
+    private_constant :NODE_MIN_MAJOR
+
+    def run
+      install_ruby_dependencies
+      ensure_node
+      install_or_update_playwright
+      configure_git_hooks
+      PredictabilityEngine.logger.info { <<~MSG }
+        Setup complete. Try:
+          predictability-engine summary data/samples/sample_data.csv
+      MSG
+    end
+
+    private
+
+    def install_ruby_dependencies
+      PredictabilityEngine.logger.info { '==> Installing Ruby dependencies' }
+      Bundler.with_unbundled_env do
+        system('bundle', 'install', '--jobs', '4', '--retry', '3') || raise(Error, 'bundle install failed')
+      end
+    end
+
+    def ensure_node
+      current = node_major_version
+      if current.nil?
+        PredictabilityEngine.logger.info { '==> Installing Node.js' }
+        manage_node(:install)
+      elsif current < NODE_MIN_MAJOR
+        PredictabilityEngine.logger.info { "==> Upgrading Node.js (found v#{current}, need v#{NODE_MIN_MAJOR}+)" }
+        manage_node(:upgrade)
+      else
+        PredictabilityEngine.logger.info { "==> Node.js v#{current} — already sufficient" }
+      end
+    end
+
+    def node_major_version
+      raw = `node --version 2>/dev/null`.strip
+      return nil if raw.empty?
+
+      raw.delete_prefix('v').split('.').first.to_i
+    rescue Errno::ENOENT
+      nil
+    end
+
+    def manage_node(action)
+      cmd = node_cmd_for(action)
+      system(*cmd) || raise(Error, "Node.js #{action} failed on #{Gem::Platform.local.os}")
+    end
+
+    def node_cmd_for(action)
+      case Gem::Platform.local.os
+      when 'darwin'
+        action == :install ? %w[brew install node] : %w[brew upgrade node]
+      when 'linux'
+        [linux_node_package_manager, 'install', '-y', 'nodejs']
+      when /mingw/
+        action == :install ? %w[choco install nodejs -y] : %w[choco upgrade nodejs -y]
+      else
+        os = Gem::Platform.local.os
+        raise Error, "Cannot auto-install Node.js on '#{os}' — install Node #{NODE_MIN_MAJOR}+ manually"
+      end
+    end
+
+    def linux_node_package_manager
+      %w[apt-get dnf].each do |pm|
+        return pm if system(pm, '--version', out: File::NULL, err: File::NULL)
+      end
+      raise Error, 'No supported package manager found (tried apt-get, dnf) — install Node.js manually'
+    end
+
+    def install_or_update_playwright
+      if !playwright_installed?
+        PredictabilityEngine.logger.info { '==> Installing Playwright (first run)' }
+        system('npm', 'install') || raise(Error, 'npm install failed')
+      elsif playwright_outdated?
+        PredictabilityEngine.logger.info { '==> Updating Playwright' }
+        system('npm', 'update', 'playwright') || raise(Error, 'npm update playwright failed')
+      else
+        PredictabilityEngine.logger.info { '==> Playwright — already up to date' }
+      end
+      install_chromium_browser
+    end
+
+    def playwright_installed?
+      File.exist?(File.join(gem_root, 'node_modules', '.bin', 'playwright'))
+    end
+
+    def playwright_outdated?
+      raw = IO.popen(%w[npm outdated --json], err: File::NULL, &:read)
+      JSON.parse(raw).key?('playwright')
+    rescue JSON::ParserError
+      false
+    end
+
+    def install_chromium_browser
+      if ENV['PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD']
+        PredictabilityEngine.logger.info { '==> Chromium install skipped (PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD set)' }
+        return
+      end
+
+      system('npx', 'playwright', 'install', 'chromium', '--with-deps') ||
+        raise(Error, 'playwright install chromium failed')
+    end
+
+    def gem_root
+      File.expand_path('../..', __dir__)
+    end
+
+    def configure_git_hooks
+      if system('git', 'rev-parse', '--is-inside-work-tree', out: File::NULL, err: File::NULL)
+        system('git', 'config', 'core.hooksPath', '.githooks') ||
+          raise(Error, 'git config core.hooksPath failed')
+        PredictabilityEngine.logger.info { '==> Git hooks configured (.githooks)' }
+      else
+        PredictabilityEngine.logger.info { '==> Git hooks skipped (not a git repository)' }
+      end
+    end
+  end
+end

data/lib/predictability_engine/simulators/monte_carlo.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module PredictabilityEngine
+  module Simulators
+    class MonteCarlo
+      DEFAULT_TRIALS = 10_000
+
+      def self.when_will_it_be_done(backlog_count, historical_throughput, trials: DEFAULT_TRIALS)
+        validate_and_run(historical_throughput, trials) do
+          remaining = backlog_count
+          days = 0
+
+          while remaining.positive?
+            remaining -= historical_throughput.sample
+            days += 1
+          end
+
+          days
+        end
+      end
+
+      def self.how_many_will_be_done(days_to_forecast, historical_throughput, trials: DEFAULT_TRIALS)
+        validate_and_run(historical_throughput, trials) do
+          total_done = 0
+          days_to_forecast.times do
+            total_done += historical_throughput.sample
+          end
+          total_done
+        end
+      end
+
+      def self.validate_and_run(historical_throughput, trials, &)
+        return [] if historical_throughput.empty?
+
+        run_simulation(trials, &)
+      end
+
+      def self.percentile(results, percentile_value)
+        return nil if results.empty?
+
+        index = (results.size * percentile_value / 100.0).ceil - 1
+        results[index]
+      end
+
+      def self.run_simulation(trials)
+        srand(42)
+        results = []
+        trials.times { results << yield }
+        results.sort!
+      ensure
+        srand
+      end
+
+      private_class_method :run_simulation, :validate_and_run
+    end
+  end
+end

data/lib/predictability_engine/simulators/monte_carlo_validator.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module PredictabilityEngine
+  module Simulators
+    class MonteCarloValidator
+      DEFAULT_VALIDATION_TRIALS = 200
+      MIN_COMPLETED_ITEMS = 10
+
+      # Hindcast calibration: randomly samples historical as-of dates, runs the primary
+      # Monte Carlo at each, and checks whether the predicted percentile days covered
+      # the actual outcome. Returns coverage ratios per percentile, or nil when there
+      # is insufficient data for any valid trial.
+      def self.calibration(
+        work_items,
+        percentiles: PredictabilityEngine::DEFAULT_PERCENTILES,
+        validation_trials: DEFAULT_VALIDATION_TRIALS,
+        primary_trials: MonteCarlo::DEFAULT_TRIALS
+      )
+        completed = work_items.select(&:completed?)
+        dates = candidate_dates(completed, validation_trials)
+        return nil if dates.empty?
+
+        trial_results = dates.map { |d| run_trial(completed, d, percentiles, primary_trials) }
+        aggregate_coverage(trial_results, percentiles, dates.size)
+      end
+
+      def self.date_range(completed)
+        sorted_ends = completed.map(&:end_date).sort
+        return nil if sorted_ends.size < MIN_COMPLETED_ITEMS
+
+        earliest_valid = sorted_ends[MIN_COMPLETED_ITEMS - 1]
+        latest_valid = sorted_ends.last - 1
+        return nil if earliest_valid > latest_valid
+
+        [earliest_valid, latest_valid]
+      end
+
+      def self.candidate_dates(completed, count)
+        range = date_range(completed)
+        return [] unless range
+
+        earliest, latest = range
+        span = (latest - earliest).to_i
+        return [] if span.zero?
+
+        srand(7)
+        dates = count.times.map { earliest + rand(span + 1) }
+        srand
+        dates
+      end
+
+      def self.run_trial(completed, as_of_date, percentiles, primary_trials)
+        in_flight = completed.select { |i| i.in_progress?(as_of_date) }
+        historical = valid_historical(completed, as_of_date, in_flight) or return nil
+
+        actual_days = (in_flight.map(&:end_date).max - as_of_date).to_i
+        results = MonteCarlo.when_will_it_be_done(in_flight.size, historical, trials: primary_trials)
+
+        percentiles.to_h { |p| [p, actual_days <= MonteCarlo.percentile(results, p)] }
+      end
+
+      def self.valid_historical(completed, as_of_date, in_flight)
+        return nil if in_flight.empty?
+
+        historical_items = completed.select { |i| i.end_date <= as_of_date }
+        return nil if historical_items.size < MIN_COMPLETED_ITEMS
+
+        historical = Calculators::Throughput.daily(historical_items).values
+        historical unless historical.all?(&:zero?)
+      end
+
+      def self.aggregate_coverage(trial_results, percentiles, total_sampled)
+        valid = trial_results.compact
+        return nil if valid.empty?
+
+        coverage = percentiles.to_h do |p|
+          [p, valid.count { |t| t[p] }.to_f / valid.size]
+        end
+        coverage.merge(trials_run: valid.size, trials_skipped: total_sampled - valid.size)
+      end
+
+      private_class_method :date_range, :candidate_dates, :run_trial, :valid_historical, :aggregate_coverage
+    end
+  end
+end

data/lib/predictability_engine/summary_visualizer/helpers.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module PredictabilityEngine
+  module SummaryVisualizer
+    module Helpers
+      def self.metric_lines(work_items, metrics, prefix: '', bold: '')
+        shared_metrics(work_items, metrics).map { |k, v| "#{prefix}#{bold}#{k}:#{bold} #{v}" }.join("\n")
+      end
+
+      def self.html_metric_li(label, value)
+        "<li><strong>#{label}:</strong> <span class='metric-value'>#{value}</span></li>"
+      end
+
+      def self.metric_list(work_items, metrics)
+        shared_metrics(work_items, metrics).map do |k, v|
+          if v.to_s.include?("\n")
+            items = v.to_s.strip.split("\n").map { |e| "<li>#{e.strip}</li>" }.join
+            "<li class='breakdown'><strong>#{k}:</strong><ul>#{items}</ul></li>"
+          else
+            html_metric_li(k, v)
+          end
+        end.join("\n")
+      end
+
+      def self.percentile_lines(metrics, percentiles, prefix: '', bold: '', suffix: '')
+        percentiles.map do |p|
+          "#{prefix}#{bold}#{p}th Percentile:#{bold} #{metrics[:"p#{p}"]} days#{suffix}"
+        end.join("\n")
+      end
+
+      def self.shared_metrics(work_items, metrics)
+        result = {
+          'Total Items': work_items.size,
+          'Completed Items': metrics[:completed].size,
+          'Average Throughput': "#{metrics[:tp_avg].round(2)} items/day"
+        }
+        Report::FACETS.each do |facet|
+          breakdown = facet_breakdown(metrics[:completed], facet)
+          result[:"#{facet[:label]} Breakdown"] = breakdown if breakdown
+        end
+        result
+      end
+
+      def self.facet_breakdown(completed_items, facet)
+        counts = completed_items.filter_map { |i| i.public_send(facet[:accessor]) }.tally
+        return nil if counts.size <= 1
+
+        "\n#{ordered_facet_entries(counts, facet).map { |e| "  #{e}" }.join("\n")}"
+      end
+
+      def self.ordered_facet_entries(counts, facet)
+        return priority_ordered_entries(counts) if facet[:key] == :priority
+
+        counts.sort_by { |_, v| -v }.map { |k, v| "#{k}: #{v}" }
+      end
+
+      def self.priority_ordered_entries(counts)
+        priority_order = Report::Constants::PRIORITY_ORDER
+        ordered = priority_order.filter_map { |p| "#{p}: #{counts[p]}" if counts[p] }
+        others  = (counts.keys - priority_order).sort.map { |p| "#{p}: #{counts[p]}" }
+        ordered + others
+      end
+
+      private_class_method :facet_breakdown, :ordered_facet_entries, :priority_ordered_entries
+
+      def self.terminal_colors(color)
+        color ? ["\e[1m", "\e[36m", "\e[0m"] : ['', '', '']
+      end
+    end
+  end
+end

data/lib/predictability_engine/summary_visualizer/renderer.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative 'helpers'
+
+module PredictabilityEngine
+  module SummaryVisualizer
+    module Renderer
+      def self.render_html_summary(work_items, metrics, percentiles)
+        html = <<~HTML
+          <h2>Flow Metrics Summary</h2>
+          <ul>
+            #{Helpers.metric_list(work_items, metrics)}
+          </ul>
+        HTML
+
+        if metrics[:aging]
+          items = aging_pairs(metrics[:aging]).map { |l, v| Helpers.html_metric_li(l, v) }.join("\n            ")
+          html += <<~HTML
+            <h3>Aging WIP Summary</h3>
+            <ul>
+              #{items}
+            </ul>
+          HTML
+        end
+
+        html += <<~HTML
+          <h3>Cycle Time Percentiles</h3>
+          <ul>
+            #{Helpers.percentile_lines(metrics, percentiles, prefix: '<li><strong>', bold: '</strong>', suffix: '</li>')}
+          </ul>
+        HTML
+        html
+      end
+
+      def self.render_terminal_summary(work_items, metrics, color, percentiles)
+        bold, cyan, reset = Helpers.terminal_colors(color)
+        out = [
+          "#{bold}Flow Metrics Summary#{reset}",
+          '--------------------',
+          Helpers.metric_lines(work_items, metrics), ''
+        ]
+
+        out += aging_summary_lines(metrics, "#{cyan}Aging WIP Summary:#{reset}", '  ') if metrics[:aging]
+
+        out += [
+          "#{cyan}Cycle Time Percentiles:#{reset}",
+          Helpers.percentile_lines(metrics, percentiles, prefix: '  '), ''
+        ]
+        out.join("\n")
+      end
+
+      def self.aging_pairs(aging)
+        [['Active WIP', "#{aging[:count]} items"],
+         ['Average WIP Age', "#{aging[:avg_age]} days"],
+         ['Oldest Item Age', "#{aging[:max_age]} days"]]
+      end
+
+      def self.aging_summary_lines(metrics, title, prefix, bold = '')
+        lines = aging_pairs(metrics[:aging]).map { |label, value| "#{prefix}#{bold}#{label}:#{bold} #{value}" }
+        [title, '', *lines, '']
+      end
+
+      def self.render_markdown_summary(work_items, metrics, percentiles)
+        render_markup_summary(work_items, metrics, percentiles, { bold: '**', head2: '##', head3: '###' })
+      end
+
+      def self.render_confluence_summary(work_items, metrics, percentiles)
+        render_markup_summary(work_items, metrics, percentiles, { bold: '*', head2: 'h2.', head3: 'h3.' })
+      end
+
+      def self.render_markup_summary(work_items, metrics, percentiles, styling)
+        head2, head3, bold = styling.values_at(:head2, :head3, :bold)
+        out = [
+          "#{head2} Flow Metrics Summary", '',
+          Helpers.metric_lines(work_items, metrics, prefix: '* ', bold: bold), ''
+        ]
+
+        out += aging_summary_lines(metrics, "#{head3} Aging WIP Summary", '* ', bold) if metrics[:aging]
+
+        out += [
+          "#{head3} Cycle Time Percentiles", '',
+          Helpers.percentile_lines(metrics, percentiles, prefix: '* ', bold: bold)
+        ]
+        out.join("\n")
+      end
+    end
+  end
+end

data/lib/predictability_engine/summary_visualizer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module PredictabilityEngine
+  module SummaryVisualizer
+    # Dynamically define metrics methods for all supported formats
+    %i[html terminal markdown confluence].each do |fmt|
+      define_singleton_method("metrics_#{fmt}") do |work_items, **opts|
+        render(work_items, fmt, **opts)
+      end
+    end
+
+    def self.render(work_items, format, percentiles: PredictabilityEngine::DEFAULT_PERCENTILES, **options)
+      stats = calculate_metrics(work_items, percentiles: percentiles)
+      case format.to_sym
+      when :html then Renderer.render_html_summary(work_items, stats, percentiles)
+      when :terminal then Renderer.render_terminal_summary(work_items, stats, options[:color], percentiles)
+      when :markdown then Renderer.render_markdown_summary(work_items, stats, percentiles)
+      when :confluence then Renderer.render_confluence_summary(work_items, stats, percentiles)
+      end
+    end
+
+    def self.calculate_metrics(work_items, percentiles: PredictabilityEngine::DEFAULT_PERCENTILES)
+      metrics = {
+        completed: PredictabilityEngine.completed_items(work_items),
+        tp_avg: Calculators::Throughput.average(work_items),
+        aging: Calculators::Aging.summary_metrics(work_items)
+      }
+      percentiles.each do |p|
+        metrics[:"p#{p}"] = Calculators::CycleTime.percentile(work_items, p)
+      end
+      metrics
+    end
+
+    private_class_method :calculate_metrics
+  end
+end

data/lib/predictability_engine/terminal_visualizer/cfd_renderer.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module PredictabilityEngine
+  module TerminalVisualizer
+    module CfdRenderer
+      def self.build_forecast_params(data)
+        start = data[:dates].first
+        {
+          start: start,
+          x_coords: data[:dates].map { |d| (d - start).to_i },
+          hist_size: data[:departed].size,
+          total_items: data[:summary][:total_items],
+          max_x: data[:dates].map { |d| (d - start).to_i }.max || 0,
+          arrivals: data[:arrivals]
+        }
+      end
+
+      def self.add_forecast_layers!(plot, data, params, percentiles)
+        add_historical_departures!(plot, data, params)
+        f_colors = { 50 => :yellow, 75 => :red, 85 => :magenta, 95 => :cyan, 98 => :white }
+        percentiles.sort.reverse.each do |p|
+          add_confidence_layer!(plot, data, params, p, sorted_pcts: percentiles.sort,
+                                                       color: f_colors[p] || :white)
+        end
+      end
+
+      def self.add_historical_departures!(plot, data, params)
+        UnicodePlot.stairs!(plot, params[:x_coords].take(params[:hist_size]), data[:departed],
+                            name: 'Departures', color: :green)
+      end
+
+      def self.add_confidence_layer!(plot, data, params, percentile, **opts)
+        color = opts[:color]
+        f_x = params[:x_coords].drop(params[:hist_size] - 1)
+        f_y = data[:forecasts][percentile].drop(params[:hist_size] - 1)
+        UnicodePlot.lineplot!(plot, f_x, f_y, name: "#{percentile}% Confidence", color: color)
+        draw_deadline!(plot, data, params, percentile, opts[:sorted_pcts])
+      end
+
+      def self.draw_deadline!(plot, data, params, percentile, sorted_pcts)
+        idx = sorted_pcts.index(percentile)
+        target_p = idx < sorted_pcts.size - 1 ? sorted_pcts[idx + 1] : percentile
+        deadline_idx = params[:hist_size] - 1 + data[:summary][:"p#{target_p}"]
+        deadline_x = params[:x_coords][deadline_idx]
+        forecast_at_deadline = data[:forecasts][percentile][deadline_idx]
+        UnicodePlot.lineplot!(plot, [deadline_x, deadline_x], [0, forecast_at_deadline], color: :normal)
+      end
+
+      private_class_method :add_historical_departures!, :add_confidence_layer!, :draw_deadline!
+    end
+  end
+end

data/lib/predictability_engine/terminal_visualizer.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'unicode_plot'
+require 'stringio'
+require_relative 'terminal_visualizer/cfd_renderer'
+
+module PredictabilityEngine
+  module TerminalVisualizer
+    def self.aging_wip(items, color: false, pcts: DEFAULT_PERCENTILES, **)
+      age_data = Calculators::Aging.item_age_data(items)
+      return 'No items currently in progress.' if age_data.empty?
+
+      PredictabilityEngine.mapped_percentiles(items, pcts)
+      plot = UnicodePlot.barplot(age_data.map { |d| d[:id].to_s }, age_data.map { |d| d[:age] },
+                                 title: 'Aging Work In Progress (Days)', color: color ? :blue : nil)
+      render_to_string(plot, color: color)
+    end
+
+    def self.cycle_time_scatter(items, title: 'Cycle Time Scatter Plot', color: false,
+                                pcts: DEFAULT_PERCENTILES, **)
+      completed = Calculators::CycleTime.completed_sorted(items)
+      return 'No completed items to plot.' if completed.empty?
+
+      start = completed.first.end_date
+      x = completed.map { |i| (i.end_date - start).to_i }
+      xlabel = "Days since #{PredictabilityEngine.format_date(start)}"
+      plot = UnicodePlot.scatterplot(x, completed.map(&:cycle_time), title: title,
+                                                                     xlabel: xlabel,
+                                                                     ylabel: 'Cycle Time (days)')
+      PredictabilityEngine.mapped_percentiles(items, pcts).each do |p|
+        UnicodePlot.lineplot!(plot, x.minmax, [p[:val], p[:val]], name: p[:label])
+      end
+      render_to_string(plot, color: color)
+    end
+
+    def self.throughput_histogram(items, title: 'Throughput Histogram', color: false, **)
+      daily = Calculators::Throughput.daily(items).values
+      return 'No throughput data to plot.' if daily.empty?
+
+      plot = UnicodePlot.histogram(daily, title: title, xlabel: 'Items per day', ylabel: 'Frequency')
+      render_to_string(plot, color: color)
+    end
+
+    def self.cycle_time_bands(items, title: 'Cycle Time Bands Over Time', color: false, **)
+      completed = PredictabilityEngine.completed_items(items)
+      return 'No completed items to plot.' if completed.empty?
+
+      labels = RawDataExporter::DONE_THRESHOLD_LABELS
+      counts = Array.new(labels.size, 0)
+      completed.each { |item| counts[RawDataExporter.threshold_index(item.cycle_time)] += 1 }
+      plot = UnicodePlot.barplot(labels, counts, title: title, xlabel: 'Items Completed')
+      render_to_string(plot, color: color)
+    end
+
+    def self.cfd_plot(work_items, title: 'Cumulative Flow Diagram', color: false, **_opts)
+      cfd = Calculators::Cfd.calculate(work_items)
+      return 'No CFD data to plot.' if cfd.empty?
+
+      start = cfd.first[:date]
+      coords = Calculators::Cfd.to_coordinates(cfd, start)
+      max_y = coords[:arrived].max || 0
+      max_x = coords[:dates].max || 0
+
+      # Arrivals first for legend and top boundary
+      plot = UnicodePlot.stairs(coords[:dates], coords[:arrived],
+                                title: title, name: 'Arrivals',
+                                xlabel: "Days since #{PredictabilityEngine.format_date(start)}", ylabel: 'Total Items',
+                                color: :blue, xlim: [0, max_x], ylim: [0, max_y])
+      # Departures next
+      UnicodePlot.stairs!(plot, coords[:dates], coords[:departed], name: 'Departures', color: :green)
+      render_to_string(plot, color: color)
+    end
+
+    def self.forecasted_cfd_plot(work_items, title: 'Forecasted Cumulative Flow Diagram', color: false,
+                                 percentiles: PredictabilityEngine::DEFAULT_PERCENTILES, **_opts)
+      data = Calculators::Cfd.forecast_series(work_items, percentiles: percentiles)
+      return cfd_plot(work_items, title: title, color: color) unless data
+
+      params = CfdRenderer.build_forecast_params(data)
+      plot = UnicodePlot.stairs(params[:x_coords], params[:arrivals],
+                                title: title, name: 'Arrivals', ylabel: 'Total Items',
+                                xlabel: "Days since #{PredictabilityEngine.format_date(params[:start])}", color: :blue,
+                                xlim: [0, params[:max_x]], ylim: [0, params[:total_items]])
+
+      CfdRenderer.add_forecast_layers!(plot, data, params, percentiles)
+      render_to_string(plot, color: color)
+    end
+
+    def self.render_to_string(plot, color: false)
+      sio = StringIO.new
+      plot.render(sio, color: color)
+      sio.string
+    end
+
+    private_class_method :render_to_string
+  end
+end

data/lib/predictability_engine/vega_visualizer/aging_wip_visualizer.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module PredictabilityEngine
+  module VegaVisualizer
+    module AgingWipVisualizer
+      def self.aging_wip(items, title: 'Aging Work In Progress',
+                         pcts: PredictabilityEngine::DEFAULT_PERCENTILES, **)
+        raw = Calculators::Aging.item_age_data(items)
+        return Vega.lite.data([]).title(title || 'Aging Work In Progress') if raw.empty?
+
+        data = raw.map { |row| row.merge(title_display: VegaVisualizer.wrap_tooltip_title(row[:title].to_s)) }
+        mapped = PredictabilityEngine.mapped_percentiles(items, pcts)
+        VegaVisualizer.apply_standard_dims(
+          Vega.lite.data(data)
+              .layer([aging_bar_layer, *aging_rule_layers(mapped)]),
+          title: title
+        )
+      end
+
+      def self.aging_bar_layer
+        { mark: { type: 'bar', stroke: 'white', strokeWidth: 0.2 },
+          encoding: { x: { field: 'id', type: 'nominal', title: 'Work Item ID', sort: '-y',
+                           axis: VegaVisualizer::LABEL_AXIS },
+                      y: VegaVisualizer.quantitative_y_axis('age', title: 'Age (days)'),
+                      color: { field: 'age', type: 'quantitative', scale: { scheme: 'yelloworangered' },
+                               legend: { orient: 'bottom', title: 'Age' } },
+                      **VegaVisualizer.item_href_and_tooltip(
+                        [{ field: 'age', type: 'quantitative', title: 'Age (days)' }]
+                      ) } }
+      end
+
+      def self.aging_rule_layers(mapped_pcts)
+        mapped_pcts.map do |p|
+          { data: { values: [{ val: p[:val], label: p[:label] }] },
+            mark: { type: 'rule', strokeDash: [4, 4] },
+            encoding: { y: VegaVisualizer.quantitative_y_axis('val', title: 'Age (days)'),
+                        color: { value: '#e45756' },
+                        tooltip: [{ field: 'label', type: 'nominal', title: 'Percentile' },
+                                  { field: 'val', type: 'quantitative', title: 'Age (days)' }] } }
+        end
+      end
+    end
+  end
+end