predictability-engine 0.6.6

data/lib/predictability_engine/jira_workflow.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'fileutils'
+
+module PredictabilityEngine
+  # Editable mapping of Jira workflow statuses → arrival/departure roles.
+  # Extracted from Jira's status catalogue, persisted to YAML, and consumed
+  # by DataSources::Jira to drive start_date / end_date selection.
+  class JiraWorkflow
+    DEFAULT_PATH_TEMPLATE = '~/.config/jira/%s.workflow.yml'
+    CATEGORY_ROLE_DEFAULTS = { 'in progress' => 'arrival', 'done' => 'departure' }.freeze
+    ROLES = %w[arrival departure].freeze
+
+    attr_reader :profile, :project, :statuses
+
+    def initialize(profile: nil, project: nil, statuses: [])
+      @profile = profile
+      @project = project
+      @statuses = statuses.map { |s| self.class.normalize_status(s) }
+    end
+
+    def self.default_path(profile_name)
+      File.expand_path(format(DEFAULT_PATH_TEMPLATE, profile_name))
+    end
+
+    def self.load(path)
+      return nil unless path && File.exist?(path)
+
+      raw = Config.load_yaml_file(path) || {}
+      new(profile: raw['profile'], project: raw['project'], statuses: raw['statuses'] || [])
+    end
+
+    def self.extract(profile_name, client: nil)
+      client ||= Config.jira_client(profile_name)
+      project = Config.jira(profile_name)[:project]
+      statuses = fetch_statuses(client).map { |s| seed_role(s) }
+      new(profile: profile_name, project: project, statuses: statuses)
+    end
+
+    # Refresh an existing config against a fresh Jira fetch:
+    # - statuses the user already annotated keep their role
+    # - brand-new statuses are added with the seeded default role
+    # - statuses that disappeared from Jira are dropped
+    def refresh(fresh)
+      existing_roles = @statuses.to_h { |s| [s[:name], s[:role]] }
+      @statuses = fresh.statuses.map do |s|
+        s.merge(role: existing_roles.key?(s[:name]) ? existing_roles[s[:name]] : s[:role])
+      end
+      @profile ||= fresh.profile
+      @project ||= fresh.project
+      self
+    end
+
+    def self.merge(configs)
+      merged = {}
+      configs.each do |cfg|
+        cfg.statuses.each { |s| merge_status(merged, s) }
+      end
+      new(statuses: merged.values)
+    end
+
+    def self.normalize_status(hash)
+      h = hash.transform_keys(&:to_s)
+      role = h['role'].to_s.empty? ? nil : h['role'].to_s
+      { name: h['name'], category: h['category'], role: role }
+    end
+
+    def write(path)
+      PredictabilityEngine.write_file(path, to_hash.to_yaml)
+      path
+    end
+
+    def to_hash
+      {
+        'profile' => @profile,
+        'project' => @project,
+        'statuses' => @statuses.map { |s| s.transform_keys(&:to_s) }
+      }.compact
+    end
+
+    def arrival_names
+      names_for('arrival')
+    end
+
+    def departure_names
+      names_for('departure')
+    end
+
+    def self.fetch_statuses(client)
+      entries = client.Status.all.map { |status| status_entry(status) }
+      entries.uniq { |s| s[:name] }
+    rescue StandardError => e
+      PredictabilityEngine.logger.warn { "Failed to fetch Jira statuses: #{e.message}" }
+      []
+    end
+
+    def self.status_entry(status)
+      category = begin
+        status.statusCategory['name'].to_s.downcase
+      rescue StandardError
+        nil
+      end
+      { name: status.name, category: category }
+    end
+
+    def self.seed_role(status)
+      status.merge(role: CATEGORY_ROLE_DEFAULTS[status[:category]])
+    end
+
+    def self.merge_status(target, status)
+      existing = target[status[:name]]
+      if existing
+        warn_conflict(existing, status) if existing[:role] && status[:role] && existing[:role] != status[:role]
+        existing[:role] ||= status[:role]
+        existing[:category] ||= status[:category]
+      else
+        target[status[:name]] = status.dup
+      end
+    end
+
+    def self.warn_conflict(existing, incoming)
+      PredictabilityEngine.logger.warn do
+        "Workflow merge conflict for '#{existing[:name]}': role " \
+          "#{existing[:role]} vs #{incoming[:role]} (kept #{existing[:role]})"
+      end
+    end
+
+    private_class_method :fetch_statuses, :status_entry, :seed_role, :merge_status, :warn_conflict
+
+    private
+
+    def names_for(role)
+      @statuses.select { |s| s[:role] == role }.map { |s| s[:name] }
+    end
+  end
+end

data/lib/predictability_engine/logger.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'semantic_logger'
+require 'fileutils'
+
+module PredictabilityEngine
+  # Custom console formatter matching current terminal output:
+  #   INFO  → plain message (no prefix)
+  #   WARN  → yellow "Warning: …"
+  #   ERROR → red    "Error: …"
+  #   DEBUG → gray   "DEBUG: …"
+  class TerminalFormatter < SemanticLogger::Formatters::Base
+    def call(log, _logger)
+      msg = log.message.to_s
+      case log.level
+      when :error then "\e[31mError: #{msg}\e[0m\n"
+      when :warn  then "\e[33mWarning: #{msg}\e[0m\n"
+      when :debug then "\e[90mDEBUG: #{msg}\e[0m\n"
+      else "#{msg}\n"
+      end
+    end
+  end
+
+  # Called from CliBase#initialize via --log-level / --log-file options.
+  # Removes only appenders previously added by this method (tracked in
+  # @_pe_appenders) so that external appenders — e.g. test StringIO captures —
+  # are never disturbed.
+  def self.setup_logging(level: 'info', log_file: nil)
+    SemanticLogger.default_level = level.to_sym
+    (@_pe_appenders || []).each { |a| SemanticLogger.remove_appender(a) }
+    @_pe_appenders = []
+    @_pe_appenders << SemanticLogger.add_appender(io: $stdout, formatter: TerminalFormatter.new)
+    return unless log_file
+
+    FileUtils.mkdir_p(File.dirname(log_file))
+    @_pe_appenders << SemanticLogger.add_appender(file_name: log_file, formatter: :json)
+  end
+
+  # Module-level logger named "PredictabilityEngine".
+  # Memoized so that all call sites share the same instance (required for RSpec
+  # `receive` mocks, and avoids allocating a new object on every log call).
+  def self.logger
+    @logger ||= SemanticLogger[self]
+  end
+end

data/lib/predictability_engine/mermaid_visualizer.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module PredictabilityEngine
+  module MermaidVisualizer
+    def self.cfd_plot(items, **_opts)
+      data = Calculators::Cfd.calculate(items).last(20)
+      dates = data.map { |d| d[:date].to_s }
+      format_mermaid_xy("Cumulative Flow Diagram (Last #{dates.size} days)", dates, 'Items',
+                        [data.map { |d| d[:arrived] }, data.map { |d| d[:departed] }],
+                        labels: %w[Arrivals Departures])
+    end
+
+    def self.forecasted_cfd_plot(items, percentiles: PredictabilityEngine::DEFAULT_PERCENTILES, **_opts)
+      data = Calculators::Cfd.forecast_series(items, percentiles: percentiles)
+      return cfd_plot(items) unless data
+
+      series = [data[:arrivals]]
+      labels = ['Arrivals']
+      hist_size = data[:departed].size
+      series << (data[:departed] + Array.new(data[:dates].size - hist_size, nil))
+      labels << 'Departures'
+      percentiles.each do |p|
+        series << data[:forecasts][p]
+        labels << "#{p}% Confidence"
+        series << build_vertical_rule(data, p, hist_size)
+        labels << "#{p}% Deadline"
+      end
+
+      format_mermaid_xy('Forecasted Cumulative Flow Diagram', data[:dates].map(&:to_s), 'Items',
+                        series, labels: labels, thin: true)
+    end
+
+    def self.build_vertical_rule(data, percentile, hist_size)
+      days = data[:summary][:"p#{percentile}"]
+      index = hist_size - 1 + days
+      res = Array.new(data[:dates].size, nil)
+      res[index] = data[:summary][:total_items] if index < res.size
+      res
+    end
+
+    def self.aging_wip(items, **_opts)
+      data = Calculators::Aging.item_age_data(items)
+      format_mermaid_xy('Aging Work In Progress', data.map { |d| d[:id] }, 'Age (days)',
+                        [data.map { |d| d[:age] }], labels: ['Age'], type: 'bar')
+    end
+
+    def self.throughput_histogram(items, **_opts)
+      counts = Calculators::Throughput.histogram_data(items)
+      format_mermaid_xy('Throughput Histogram', counts.map { |c| c[0] }, 'Frequency',
+                        [counts.map { |c| c[1] }], labels: ['Frequency'], type: 'bar')
+    end
+
+    def self.cycle_time_scatter(items, percentiles: PredictabilityEngine::DEFAULT_PERCENTILES, **_opts)
+      completed = Calculators::CycleTime.completed_sorted(items)
+      return '' if completed.empty?
+
+      dates = completed.map { |i| i.end_date.to_s }.uniq.last(20)
+      series = percentiles.map { |p| dates.map { |d| pct_at(completed, d, p) } }
+      labels = percentiles.map { |p| "#{p}th Percentile" }
+
+      format_mermaid_xy("Cycle Time Trend (Last #{dates.size} days)", dates, 'Cycle Time (days)',
+                        series, labels: labels, thin: true)
+    end
+
+    def self.pct_at(items, date, pct)
+      PredictabilityEngine.cycle_time_percentile(items.select { |i| i.end_date <= Date.parse(date) }, pct)
+    end
+
+    def self.format_mermaid_xy(title, x_axis, y_label, series, opts = {})
+      ['xychart-beta', "    title \"#{title}\"", "    x-axis [\"#{format_x_axis(x_axis, opts).join('", "')}\"]",
+       "    y-axis \"#{y_label}\"", *format_series(series, opts)].join("\n")
+    end
+
+    def self.format_x_axis(x_axis, opts)
+      x_axis.each_with_index.map do |x, i|
+        val = x.to_s.gsub('"', '')
+        opts[:thin] && (i % 7 != 0) ? ' ' : val
+      end
+    end
+
+    def self.format_series(series, opts)
+      type = opts[:type] || 'line'
+      labels = opts[:labels]
+      series.each_with_index.map do |s, i|
+        label = labels && labels[i] ? " \"#{labels[i]}\"" : ''
+        "    #{type}#{label} [#{s.map { |v| v.nil? ? 'NaN' : v }.join(', ')}]"
+      end
+    end
+
+    private_class_method :format_x_axis, :format_series
+  end
+end

data/lib/predictability_engine/models/work_item.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module PredictabilityEngine
+  module Models
+    class WorkItem
+      attr_accessor :id, :title, :type, :priority, :start_date, :end_date, :url
+
+      def initialize(item_id:, title: nil, type: nil, priority: nil, start_date: nil, end_date: nil, url: nil) # rubocop:disable Metrics/ParameterLists
+        @id = item_id
+        @title = title
+        @type = type
+        @priority = priority
+        @start_date = start_date ? Date.parse(start_date.to_s) : nil
+        @end_date = end_date ? Date.parse(end_date.to_s) : nil
+        @url = url
+      end
+
+      def cycle_time
+        return nil unless completed?
+
+        (@end_date - @start_date).to_i + 1 # Include both start and end days
+      end
+
+      def age(date = PredictabilityEngine.today)
+        return nil unless in_progress?(date)
+
+        (date - @start_date).to_i + 1
+      end
+
+      def completed?
+        !@end_date.nil? && !@start_date.nil?
+      end
+
+      def in_progress?(date)
+        return false unless @start_date
+        return false if date < @start_date
+        return true if @end_date.nil? || date < @end_date
+
+        false
+      end
+    end
+  end
+end

data/lib/predictability_engine/pdf_visualizer/primitives.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module PredictabilityEngine
+  module PdfVisualizer
+    module Primitives
+      def self.chart_width = 250
+      def self.chart_height = 100
+
+      def self.draw_line_chart(pdf, _labels, series)
+        max_y = series.map { |s| s[:values].max }.max || 1
+
+        draw_canvas(pdf) do
+          series.each { |s| draw_series(pdf, s, series.first[:values].size, max_y) }
+        end
+        draw_legend(pdf, series)
+      end
+
+      def self.draw_series(pdf, series_data, labels_count, max_y)
+        pdf.stroke_color series_data[:color]
+        points = series_data[:values].each_with_index.map do |v, i|
+          [x_coord(i, labels_count), y_coord(v, max_y)]
+        end
+
+        pdf.stroke do
+          pdf.move_to(*points[0])
+          points[1..].each { |p| pdf.line_to(*p) }
+        end
+      end
+
+      def self.draw_legend(pdf, series)
+        # Use smaller legend for dashboard
+        series.each do |s|
+          pdf.fill_color s[:color]
+          pdf.fill_rectangle [0, pdf.cursor], 8, 8
+          pdf.fill_color '000000'
+          pdf.draw_text s[:label], at: [12, pdf.cursor - 6], size: 6
+          pdf.move_down 10
+        end
+      end
+
+      def self.draw_bar_chart(pdf, labels, values)
+        max_y = values.max || 1
+        bar_width = labels.empty? ? chart_width : chart_width / labels.size.to_f
+
+        draw_canvas(pdf) do
+          values.each_with_index do |v, i|
+            h = (v.to_f / max_y) * chart_height
+            pdf.fill_color '3366CC'
+            pdf.fill_rectangle [i * bar_width, h], [bar_width - 2, 1].max, h
+          end
+        end
+      end
+
+      def self.draw_scatter_plot(pdf, labels, values)
+        max_y = values.max || 1
+
+        draw_canvas(pdf) do
+          values.each_with_index do |v, i|
+            pdf.fill_circle [x_coord(i, labels.size), y_coord(v, max_y)], 1.5
+          end
+        end
+      end
+
+      def self.x_coord(index, total)
+        total <= 1 ? 0 : (index.to_f / (total - 1)) * chart_width
+      end
+
+      def self.y_coord(value, max_y)
+        (value.to_f / max_y) * chart_height
+      end
+
+      def self.draw_canvas(pdf)
+        pdf.bounding_box([0, pdf.cursor], width: chart_width, height: chart_height) do
+          pdf.stroke_bounds
+          yield
+          pdf.stroke_color '000000'
+          pdf.fill_color '000000'
+        end
+        pdf.move_down 5
+      end
+    end
+  end
+end

data/lib/predictability_engine/pdf_visualizer.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative 'pdf_visualizer/primitives'
+
+module PredictabilityEngine
+  module PdfVisualizer
+    def self.draw_chart(pdf, chart_id, work_items, percentiles: PredictabilityEngine::DEFAULT_PERCENTILES)
+      case chart_id
+      when :cfd_plot then draw_cfd(pdf, work_items)
+      when :forecasted_cfd_plot then draw_forecasted_cfd(pdf, work_items, percentiles: percentiles)
+      when :throughput_histogram then draw_throughput(pdf, work_items)
+      when :cycle_time_scatter then draw_scatter(pdf, work_items, percentiles: percentiles)
+      when :aging_wip then draw_aging(pdf, work_items, percentiles: percentiles)
+      end
+    end
+
+    def self.draw_aging(pdf, work_items, **_opts)
+      data = Calculators::Aging.item_age_data(work_items)
+      Primitives.draw_bar_chart(pdf, data.map { |d| d[:id].to_s }, data.map { |d| d[:age] })
+    end
+
+    def self.draw_cfd(pdf, work_items)
+      cfd_data = Calculators::Cfd.calculate(work_items).last(30)
+      series = [
+        { label: 'Arrivals', values: cfd_data.map { |d| d[:arrived] }, color: '0000FF' },
+        { label: 'Departures', values: cfd_data.map { |d| d[:departed] }, color: '00FF00' }
+      ]
+      Primitives.draw_line_chart(pdf, cfd_data.map { |d| d[:date].to_s }, series)
+    end
+
+    def self.draw_throughput(pdf, work_items)
+      counts = Calculators::Throughput.histogram_data(work_items)
+      Primitives.draw_bar_chart(pdf, counts.map { |k, _v| k.to_s }, counts.map { |_k, v| v })
+    end
+
+    def self.draw_scatter(pdf, work_items, percentiles: PredictabilityEngine::DEFAULT_PERCENTILES)
+      data = Calculators::CycleTime.completed_sorted(work_items)
+                                   .map { |i| [i.end_date.to_s, i.cycle_time] }
+
+      Primitives.draw_scatter_plot(pdf, data.map(&:first), data.map { |d| d[1] })
+
+      pcts = PredictabilityEngine.mapped_percentiles(work_items, percentiles)
+      pdf.move_down 10
+      pdf.text "Percentiles: #{pcts.map { |p| "#{p[:label]}: #{p[:val]}" }.join(', ')}", size: 8
+    end
+
+    def self.draw_forecasted_cfd(pdf, work_items, percentiles: PredictabilityEngine::DEFAULT_PERCENTILES)
+      forecast = Calculators::Cfd.forecast_series(work_items, percentiles: percentiles)
+      return draw_cfd(pdf, work_items) unless forecast
+
+      series = [
+        { label: 'Arrivals', values: forecast[:arrivals], color: '0000FF' },
+        { label: 'Departures', values: forecast[:departed], color: '00FF00' }
+      ]
+
+      f_colors = %w[E6B800 CC0000 800080 008080 333333] # Darker versions of yellow, red, magenta, cyan, gray
+      percentiles.sort.each_with_index do |p, i|
+        series << { label: "#{p}% Conf.", values: forecast[:forecasts][p], color: f_colors[i % f_colors.size] }
+      end
+
+      Primitives.draw_line_chart(pdf, forecast[:dates].map(&:to_s), series)
+    end
+  end
+end

data/lib/predictability_engine/raw_data_exporter.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+module PredictabilityEngine
+  module RawDataExporter
+    DONE_THRESHOLDS = [1, 7, 14, 21, 28].freeze
+    DONE_THRESHOLD_LABELS = (DONE_THRESHOLDS.map { |d| d == 1 ? '≤ 1 day' : "≤ #{d} days" } +
+                             ["> #{DONE_THRESHOLDS.last} days"]).freeze
+
+    HEADERS = [
+      'ID', 'Title', 'Type', 'Priority',
+      'Start Date', 'End Date', 'Status',
+      'YYYY-Week', 'YYYY-MM', 'YYYY',
+      'Cycle Time (days)', 'Current Age (days)', 'URL',
+      'Done ≤ 1 day', 'Done ≤ 7 days', 'Done ≤ 14 days',
+      'Done ≤ 21 days', 'Done ≤ 28 days'
+    ].freeze
+
+    def self.item_row(item)
+      today = PredictabilityEngine.today
+      ct    = item.cycle_time
+      age   = item.completed? ? nil : item.age(today)
+      flags = DONE_THRESHOLDS.map { |d| ct ? ct <= d : nil }
+      date  = item.end_date
+      [item.id, item.title, item.type, item.priority,
+       item.start_date, item.end_date,
+       (item.completed? ? 'Done' : 'In Progress'),
+       PredictabilityEngine.format_year_week(date),
+       PredictabilityEngine.format_year_month(date),
+       date&.to_date&.year,
+       ct, age, item.url.to_s, *flags]
+    end
+
+    def self.threshold_index(cycle_time)
+      DONE_THRESHOLDS.index { |d| cycle_time <= d } || DONE_THRESHOLDS.size
+    end
+
+    def self.generate_csv(items)
+      CSV.generate do |csv|
+        csv << HEADERS
+        items.each { |item| csv << item_row(item) }
+      end
+    end
+  end
+end

data/lib/predictability_engine/report/constants.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module PredictabilityEngine
+  class Report
+    module Constants
+      PRIORITY_ORDER = %w[Highest High Medium Low Lowest].freeze
+
+      CHART_CONFIG = {
+        aging_wip: { title: 'Aging Work In Progress' },
+        forecasted_cfd_plot: { title: 'Forecasted Cumulative Flow Diagram', vega: :forecasted_cfd },
+        cfd_plot: { title: 'Cumulative Flow Diagram', vega: :cfd },
+        cycle_time_scatter: { title: 'Cycle Time Scatter Plot' },
+        throughput_histogram: { title: 'Throughput Histogram' },
+        cycle_time_bands: { title: 'Cycle Time Bands Over Time' }
+      }.freeze
+
+      FORMAT_CONFIG = {
+        terminal: { h1: ->(t) { "=== #{t} ===" }, h2: ->(t) { "\n=== #{t} ===" },
+                    code: ->(_t, c) { c }, aliases: %i[console ascii], layout: :standard },
+        markdown: { h1: ->(t) { "# #{t}\n" }, h2: ->(t) { "\n## #{t}" },
+                    code: ->(_t, c) { "```\n#{c}\n```" }, aliases: [:md], layout: :standard },
+        confluence: { h1: ->(t) { "h1. #{t}\n" }, h2: ->(t) { "\nh2. #{t}" },
+                      code: ->(t, c) { "{code:title=#{t}}\n#{c}\n{code}" }, aliases: [:conf], layout: :standard },
+        html: { layout: :landscape },
+        pdf: { layout: :landscape },
+        png: { layout: :landscape },
+        ppt: { layout: :landscape },
+        landscape: { aliases: [:dashboard], layout: :landscape },
+        a3_landscape: { format: 'A3', landscape: true, layout: :landscape },
+        raw_csv: {},
+        xlsx: {}
+      }.freeze
+
+      FONT_PATHS = [
+        '/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf',
+        '/usr/share/fonts/truetype/liberation/LiberationMono-Regular.ttf',
+        '/usr/share/fonts/TTF/DejaVuSansMono.ttf',
+        '/System/Library/Fonts/Supplemental/Courier New.ttf',
+        '/Library/Fonts/Courier New.ttf',
+        'C:/Windows/Fonts/cour.ttf'
+      ].freeze
+
+      FONT_BOLD_PATHS = [
+        '/usr/share/fonts/truetype/dejavu/DejaVuSansMono-Bold.ttf',
+        '/usr/share/fonts/truetype/liberation/LiberationMono-Bold.ttf',
+        '/usr/share/fonts/TTF/DejaVuSansMono-Bold.ttf',
+        '/System/Library/Fonts/Supplemental/Courier New Bold.ttf',
+        '/Library/Fonts/Courier New Bold.ttf',
+        'C:/Windows/Fonts/courbd.ttf'
+      ].freeze
+
+      RESOLUTION_CONFIG = {
+        '5k' => [5120, 2880],
+        '4k' => [3840, 2160],
+        'hd' => [1920, 1080],
+        'a0' => [7680, 5432],
+        'a1' => [5432, 3838],
+        'a2' => [3838, 2713],
+        'a3' => [2713, 1918],
+        'a4' => [1918, 1356],
+        'a5' => [1356, 956],
+        'a6' => [956, 678]
+      }.freeze
+
+      DEFAULT_SIZE = 'a4'
+      DEFAULT_FORECAST_HISTORY = '4w'
+      DEFAULT_HISTORICAL_RANGE = 'all'
+    end
+  end
+end

data/lib/predictability_engine/report/image_generator.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative '../report'
+
+module PredictabilityEngine
+  class Report
+    module ImageGenerator
+      def self.generate(report, base_dir, width: 800, height: 600, scale: 1)
+        images_path = File.join(base_dir, 'images')
+        FileUtils.mkdir_p(images_path)
+        temp_html = "tmp/images_#{report.object_id}.html"
+        File.write(temp_html, report.render_html(layout: :standard))
+
+        require 'playwright'
+        Playwright.create(playwright_cli_executable_path: report.playwright_bin) do |playwright|
+          playwright.chromium.launch(**report.playwright_chromium_launch_opts) do |browser|
+            page = browser.new_page(viewport: { width: width, height: height },
+                                    deviceScaleFactor: scale)
+            page.goto("file://#{File.expand_path(temp_html)}")
+            sleep 2
+            Constants::CHART_CONFIG.each_key { |id| capture_chart(page, id, images_path) }
+          end
+        end
+        images_path
+      ensure
+        FileUtils.rm_f(temp_html) if temp_html
+      end
+
+      def self.capture_chart(page, chart_id, images_path)
+        title = Constants::CHART_CONFIG[chart_id][:title]
+        page.locator(".chart-panel:has(h2:text-is(\"#{title}\"))")
+            .screenshot(path: File.join(images_path, "#{chart_id}.png"))
+      end
+    end
+  end
+end