predictability-engine 0.6.6

data/lib/predictability_engine/data_sources/jira_yaml.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module PredictabilityEngine
+  module DataSources
+    class JiraYaml
+      PROJECT_KEY_PATTERN = /\A[A-Z][A-Z0-9]+\z/
+
+      attr_reader :path, :config
+
+      def initialize(path)
+        @path = Pathname.new(path)
+        @config = load_config
+      end
+
+      def profile
+        return @config['jira_profile'] if @config['jira_profile']
+        return nil unless @path.basename.to_s.count('.') >= 2
+
+        @path.basename.to_s.split('.').first
+      end
+
+      def query
+        @config['query'] || project_query || filter_query || convention_query
+      end
+
+      def priority_aliases
+        profile_priority_aliases.merge(inline_priority_aliases)
+      end
+
+      def workflow_config_path
+        raw = @config['workflow_config']
+        if raw && !raw.to_s.empty?
+          return Pathname.new(raw).absolute? ? raw : File.expand_path(raw, @path.dirname.to_s)
+        end
+
+        name = middle_segment
+        return nil if name.nil? || name.empty?
+
+        candidate = File.expand_path("~/.config/jira/#{name}.workflow.yml")
+        candidate if File.exist?(candidate)
+      end
+
+      private
+
+      def inline_priority_aliases
+        raw = @config['priority_aliases']
+        stringify_hash(raw)
+      end
+
+      def profile_priority_aliases
+        return {} unless profile
+
+        path = File.expand_path("~/.config/jira/#{profile}.priorities.yml")
+        return {} unless File.exist?(path)
+
+        stringify_hash(YAML.load_file(path))
+      end
+
+      def stringify_hash(raw)
+        return {} unless raw.is_a?(Hash)
+
+        raw.transform_keys(&:to_s).transform_values(&:to_s)
+      end
+
+      def load_config
+        return {} unless @path.exist?
+
+        YAML.load_file(@path) || {}
+      end
+
+      def middle_segment
+        if @path.basename.to_s.count('.') >= 2
+          @path.basename.to_s.split('.')[1...-1].join('.')
+        else
+          @path.basename.to_s.sub(@path.extname, '')
+        end
+      end
+
+      def convention_query
+        name = middle_segment
+        return nil if name.nil? || name.empty?
+        return "(project = \"#{name}\" OR filter = \"#{name}\")" if name.match?(PROJECT_KEY_PATTERN)
+
+        "filter = \"#{name}\""
+      end
+
+      def project_query
+        return nil unless @config['project']
+
+        "project = \"#{@config['project']}\""
+      end
+
+      def filter_query
+        return "filter = \"#{@config['filter_id']}\"" if @config['filter_id']
+        return "filter = \"#{@config['filter_name']}\"" if @config['filter_name']
+
+        nil
+      end
+    end
+  end
+end

data/lib/predictability_engine/duration.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module PredictabilityEngine
+  module Duration
+    UNITS = { 'd' => 1, 'w' => 7, 'm' => 30 }.freeze
+
+    def self.parse(spec)
+      return nil if spec.nil?
+
+      match = spec.to_s.strip.downcase.match(/\A(\d+)([dwm])\z/)
+      raise ArgumentError, "Invalid duration #{spec.inspect} (expected e.g. 1w, 2m, 30d)" unless match
+
+      match[1].to_i * UNITS.fetch(match[2])
+    end
+  end
+end

data/lib/predictability_engine/excel_exporter.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'caxlsx'
+require_relative 'raw_data_exporter'
+
+module PredictabilityEngine
+  module ExcelExporter
+    CAPTURE_WIDTH  = 1920
+    CAPTURE_HEIGHT = 1080
+    CHART_SCALE = 2 # deviceScaleFactor: PNG is 2× logical size → crisp on HiDPI/4K screens
+
+    def self.generate(items, images_path: nil)
+      Axlsx::Package.new do |p|
+        add_work_items_sheet(p.workbook, items)
+        add_chart_sheets(p.workbook, images_path) if images_path
+        return p.to_stream.read
+      end
+    end
+
+    def self.add_work_items_sheet(workbook, items)
+      workbook.add_worksheet(name: 'Work Items') do |sheet|
+        sheet.add_row(RawDataExporter::HEADERS)
+        items.each { |item| sheet.add_row(RawDataExporter.item_row(item)) }
+      end
+    end
+
+    def self.add_chart_sheets(workbook, images_path)
+      Dir.glob(File.join(images_path, '*.png')).each do |img_path|
+        sheet_name = File.basename(img_path, '.png').tr('_', ' ').split.map(&:capitalize).join(' ')
+        workbook.add_worksheet(name: sheet_name[0, 31]) do |sheet|
+          sheet.page_setup.set(orientation: :landscape)
+          png_w, png_h = png_dimensions(img_path)
+          sheet.add_image(image_src: img_path, noSelect: true, noMove: true) do |image|
+            image.width  = png_w / CHART_SCALE
+            image.height = png_h / CHART_SCALE
+            image.start_at(0, 0)
+          end
+        end
+      end
+    end
+
+    def self.png_dimensions(path)
+      File.binread(path, 24).unpack('x16NN')
+    end
+
+    private_class_method :add_work_items_sheet, :add_chart_sheets, :png_dimensions
+  end
+end

data/lib/predictability_engine/html_style.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module PredictabilityEngine
+  HTML_BASE_STYLE = 'font-family: sans-serif; background: #f8f9fa;'
+
+  HTML_STYLE_LANDSCAPE = <<~CSS.freeze
+    <style>
+      body { #{HTML_BASE_STYLE} margin: 0; padding: 15px; box-sizing: border-box; display: flex; flex-direction: column; background: #f4f7f6; }
+      header { display: flex; justify-content: space-between; align-items: baseline; padding: 0 10px 10px 10px; border-bottom: 2px solid #e9ecef; margin-bottom: 15px; }
+      h1 { margin: 0; font-size: 1.5rem; color: #2c3e50; font-weight: 700; }
+      .nav-links { display: flex; gap: 10px; list-style: none; margin: 0; padding: 0; align-items: center; }
+      .nav-links li { margin: 0; display: block; }
+      .nav-links a { text-decoration: none; color: #3498db; font-size: 0.9rem; padding: 5px 12px; border-radius: 20px; border: 1.5px solid #3498db; font-weight: 600; transition: all 0.2s; }
+      .nav-links a:hover { background: #3498db; color: white; }
+      .nav-links a.active { background: #2c3e50; color: white; border-color: #2c3e50; cursor: default; }
+      .nav-links li.nav-sep { color: #bbb; padding: 0 4px; user-select: none; }
+      .dashboard-container { display: grid; grid-template-columns: 260px 1fr 1fr 1fr; grid-template-rows: 1fr 1fr; gap: 15px; flex-grow: 1; min-height: 0; min-width: 1300px; }
+      .summary-panel { grid-row: span 2; background: white; padding: 20px; border-radius: 12px; box-shadow: 0 4px 6px rgba(0,0,0,0.05); overflow-y: auto; border: 1px solid #e9ecef; }
+      .summary-panel h2 { font-size: 1.25rem; margin-top: 0; color: #2c3e50; border-bottom: 2px solid #3498db; padding-bottom: 8px; margin-bottom: 15px; }
+      .summary-panel h3 { font-size: 1.1rem; color: #34495e; margin-top: 25px; border-bottom: 1px solid #eee; padding-bottom: 5px; }
+      .chart-panel { background: white; padding: 15px; border-radius: 12px; box-shadow: 0 4px 6px rgba(0,0,0,0.05); display: flex; flex-direction: column; border: 1px solid #e9ecef; min-height: 280px; min-width: 0; }
+      .panel-header { display: flex; align-items: center; gap: 6px; margin-bottom: 10px; }
+      .panel-header h2 { margin: 0; flex-grow: 1; font-size: 1rem; color: #34495e; font-weight: 600; }
+      .chart-container { flex-grow: 1; min-height: 0; width: 100%; overflow: hidden; display: flex; justify-content: center; align-items: center; }
+      .chart-container > div { width: 100% !important; height: 100% !important; }
+      ul { list-style: none; padding: 0; margin: 10px 0; }
+      li { margin-bottom: 8px; font-size: 0.95rem; color: #505d6b; display: flex; flex-wrap: wrap; gap: 0 8px; }
+      li strong { color: #2c3e50; white-space: nowrap; }
+      .metric-value { margin-left: auto; text-align: right; }
+
+      @media screen {
+        body { height: 100vh; overflow: auto; }
+      }
+
+      @media print {
+        body { height: 100vh; overflow: hidden; padding: 5px; background: white; }
+        .dashboard-container { min-width: 0; gap: 8px; }
+        .chart-panel, .summary-panel { box-shadow: none; border: 1px solid #eee; padding: 8px; }
+        header { margin-bottom: 8px; padding-bottom: 5px; }
+        h1 { font-size: 1.2rem; }
+        .vega-bindings { display: none; }
+        .chart-expand { display: none; }
+        .nav-links { display: none; }
+      }
+
+      .vega-bindings { font-size: 0.85rem; }
+      .chart-expand { flex-shrink: 0; background: none; border: none; cursor: pointer; font-size: 1rem; color: #adb5bd; padding: 2px 4px; border-radius: 4px; line-height: 1; transition: color 0.2s, background 0.2s; }
+      .chart-expand:hover { color: #2c3e50; background: rgba(0,0,0,0.06); }
+      .chart-expand::before { content: '⛶'; }
+      .chart-panel.fullscreen .chart-expand::before { content: '✕'; }
+      .chart-panel.fullscreen { position: fixed; inset: 0; z-index: 1000; border-radius: 0; }
+      .fullscreen-backdrop { position: fixed; inset: 0; background: rgba(0,0,0,0.6); z-index: 999; }
+      .vg-tooltip td { vertical-align: top !important; }
+      .vg-tooltip td.value { white-space: pre-wrap !important; max-width: 250px !important; }
+
+      li.breakdown { flex-direction: column; align-items: flex-start; }
+      li.breakdown ul { list-style: none; padding: 0 0 0 10px; margin: 4px 0 0 0; }
+      li.breakdown ul li { display: block; margin-bottom: 2px; justify-content: flex-start; }
+    </style>
+  CSS
+
+  private_constant :HTML_BASE_STYLE, :HTML_STYLE_LANDSCAPE
+end

data/lib/predictability_engine/html_templates.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module PredictabilityEngine
+  HTML_HEADER = <<~HTML
+    <head>
+      <title>{{TITLE}}</title>
+      <script src="https://cdn.jsdelivr.net/npm/vega@5"></script>
+      <script src="https://cdn.jsdelivr.net/npm/vega-lite@5"></script>
+      <script src="https://cdn.jsdelivr.net/npm/vega-embed@6"></script>
+  HTML
+
+  HTML_BASE = <<~HTML.freeze
+    <!DOCTYPE html>
+    <html>
+    #{HTML_HEADER}
+    {{STYLE}}
+    </head>
+    <body>
+      {{BODY}}
+    </body>
+    </html>
+  HTML
+
+  HTML_LANDSCAPE_BODY = <<~HTML
+    <header>
+      <h1>{{TITLE}}</h1>
+      <nav>{{NAV_BAR}}</nav>
+      <div style="font-size: 0.8rem; color: #6c757d;">Generated: {{DATE}}</div>
+    </header>
+    <div class="dashboard-container">
+      <div class="summary-panel">{{SUMMARY_CONTENT}}</div>
+      {{CHART_PANELS}}
+    </div>
+    <script>
+      function toggleFullscreen(btn) {
+        var panel = btn.closest('.chart-panel');
+        if (panel.classList.contains('fullscreen')) {
+          panel.classList.remove('fullscreen');
+          var bd = document.querySelector('.fullscreen-backdrop');
+          if (bd) bd.remove();
+        } else {
+          var bd = document.createElement('div');
+          bd.className = 'fullscreen-backdrop';
+          bd.onclick = function() { toggleFullscreen(btn); };
+          document.body.appendChild(bd);
+          panel.classList.add('fullscreen');
+        }
+        setTimeout(function() { window.dispatchEvent(new Event('resize')); }, 50);
+      }
+      document.addEventListener('keydown', function(e) {
+        if (e.key !== 'Escape') return;
+        var fp = document.querySelector('.chart-panel.fullscreen');
+        if (fp) toggleFullscreen(fp.querySelector('.chart-expand'));
+      });
+      var obs = new MutationObserver(function() {
+        document.querySelectorAll('.chart-panel').forEach(function(panel) {
+          var bindings = panel.querySelector('.vega-bindings');
+          var header = panel.querySelector('.panel-header');
+          var btn = header && header.querySelector('.chart-expand');
+          if (bindings && btn && bindings.parentElement !== header) {
+            header.insertBefore(bindings, btn);
+          }
+        });
+      });
+      obs.observe(document.body, { childList: true, subtree: true });
+    </script>
+  HTML
+
+  private_constant :HTML_HEADER, :HTML_BASE, :HTML_LANDSCAPE_BODY
+end

data/lib/predictability_engine/jira_auth/base.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module PredictabilityEngine
+  module JiraAuth
+    class Base
+      def initialize(config)
+        @config = config
+      end
+
+      def jira_options(_base_options)
+        raise NotImplementedError, "#{self.class} must implement jira_options"
+      end
+
+      def post_init(_client); end
+
+      protected
+
+      def bearer_merge(base_options, token)
+        base_options.merge(
+          auth_type: :basic,
+          default_headers: base_options[:default_headers].merge('Authorization' => "Bearer #{token}")
+        )
+      end
+    end
+  end
+end

data/lib/predictability_engine/jira_auth/basic.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module PredictabilityEngine
+  module JiraAuth
+    class Basic < Base
+      def jira_options(base_options)
+        base_options.merge(
+          username: @config[:email],
+          password: @config[:token],
+          auth_type: :basic
+        )
+      end
+    end
+  end
+end

data/lib/predictability_engine/jira_auth/bearer.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module PredictabilityEngine
+  module JiraAuth
+    class Bearer < Base
+      def jira_options(base_options)
+        bearer_merge(base_options, @config[:bearer_token])
+      end
+    end
+  end
+end

data/lib/predictability_engine/jira_auth/cookie.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module PredictabilityEngine
+  module JiraAuth
+    class Cookie < Base
+      def jira_options(base_options)
+        base_options.merge(
+          auth_type: :basic,
+          use_cookies: true,
+          additional_cookies: [@config[:auth_cookie]]
+        )
+      end
+    end
+  end
+end

data/lib/predictability_engine/jira_auth/mfa_api.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'net/https'
+require 'json'
+require 'rotp'
+
+module PredictabilityEngine
+  module JiraAuth
+    class MfaApi < Base
+      def jira_options(base_options)
+        bearer_merge(base_options, fetch_token)
+      end
+
+      private
+
+      def fetch_token
+        otp = ROTP::TOTP.new(@config[:totp_secret]).now
+        uri = URI(@config[:mfa_login_url])
+        response = Net::HTTP.post(uri, build_payload(otp).to_json, 'Content-Type' => 'application/json')
+        raise Error, "MFA login failed (HTTP #{response.code}): #{response.body}" unless response.is_a?(Net::HTTPOK)
+
+        JSON.parse(response.body).fetch(token_field) do
+          raise Error, "MFA login response missing field '#{token_field}'"
+        end
+      end
+
+      def build_payload(otp)
+        { username: @config[:email], password: @config[:password], otp: otp }
+      end
+
+      def token_field
+        @config[:mfa_token_field] || 'access_token'
+      end
+    end
+  end
+end

data/lib/predictability_engine/jira_auth/mfa_browser.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'net/https'
+require 'uri'
+
+module PredictabilityEngine
+  module JiraAuth
+    # Browser-assisted IdP authentication for MFA gateways.
+    #
+    # Two sub-modes selected by `idp_callback_port`:
+    #
+    # A. Manual-paste (default, no extra deps):
+    #    Prints the idp_login_url and asks the user to paste back
+    #    the resulting bearer token or cookie string.
+    #
+    # B. Local callback server (experimental, set idp_callback_port: PORT):
+    #    Starts a WEBrick listener on localhost:PORT, opens the browser,
+    #    captures the token/code from the redirect query params, then
+    #    exchanges a code for a token if mfa_token_exchange_url is set.
+    class MfaBrowser < Base
+      CALLBACK_TIMEOUT = 120
+
+      def jira_options(base_options)
+        bearer_merge(base_options, @config[:idp_callback_port] ? callback_server_flow : manual_paste_flow)
+      end
+
+      private
+
+      def manual_paste_flow
+        $stdout.puts "\nOpen this URL in your browser to authenticate:"
+        $stdout.puts "  #{@config[:idp_login_url]}"
+        $stdout.puts "\nAfter logging in, paste the bearer token below and press Enter:"
+        $stdout.print '> '
+        token = $stdin.gets.to_s.strip
+        raise Error, 'No token provided' if token.empty?
+
+        token
+      end
+
+      # @experimental
+      def callback_server_flow
+        require 'webrick'
+        port = Integer(@config[:idp_callback_port])
+        token_queue = Queue.new
+
+        server = build_callback_server(port, token_queue)
+        open_browser(callback_url(port))
+
+        PredictabilityEngine.logger.info { "Waiting for IdP callback on port #{port}..." }
+        token = Timeout.timeout(CALLBACK_TIMEOUT) { token_queue.pop }
+        raise Error, 'No token received from IdP callback' if token.nil? || token.empty?
+
+        token
+      ensure
+        server&.shutdown
+      end
+
+      def build_callback_server(port, token_queue)
+        server = WEBrick::HTTPServer.new(Port: port, Logger: WEBrick::Log.new(nil, 0),
+                                         AccessLog: [])
+        server.mount_proc('/callback') do |req, res|
+          token_queue.push(req.query['token'] || req.query['access_token'] || req.query['code'])
+          res.body = 'Authentication received. You may close this tab.'
+          server.shutdown
+        end
+        Thread.new { server.start }
+        server
+      end
+
+      def callback_url(port)
+        "#{@config[:idp_login_url]}&redirect_uri=#{URI.encode_www_form_component("http://localhost:#{port}/callback")}"
+      end
+
+      def open_browser(url)
+        commands = %w[xdg-open open start]
+        cmd = commands.find { |c| system("which #{c} > /dev/null 2>&1") }
+        if cmd
+          system("#{cmd} '#{url}'")
+        else
+          $stdout.puts "Could not open browser automatically. Please visit:\n  #{url}"
+        end
+      end
+    end
+  end
+end

data/lib/predictability_engine/jira_auth.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'jira_auth/base'
+require_relative 'jira_auth/basic'
+require_relative 'jira_auth/bearer'
+require_relative 'jira_auth/cookie'
+require_relative 'jira_auth/mfa_api'
+require_relative 'jira_auth/mfa_browser'
+
+module PredictabilityEngine
+  module JiraAuth
+    MODES = %w[basic bearer cookie mfa_api mfa_browser].freeze
+
+    def self.build(config)
+      mode = config[:auth_mode].to_s
+      mode = 'basic' if mode.empty?
+      raise Error, "Unknown Jira auth_mode '#{mode}'" unless MODES.include?(mode)
+
+      const_get(mode.split('_').map(&:capitalize).join).new(config)
+    end
+  end
+end

data/lib/predictability_engine/jira_config_prompter.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module PredictabilityEngine
+  # Mixin providing interactive credential prompts for `jira_config --auth-mode`.
+  # Relies on `ask` / `ask_secret` being defined by the including class (Thor).
+  module JiraConfigPrompter
+    def build_profile_data(site, context_path, mode)
+      data = { 'site' => site }
+      data['context_path'] = context_path unless context_path.strip.empty?
+      data['auth_mode'] = mode unless mode == 'basic'
+      data.merge!(prompt_auth_fields(mode))
+      data
+    end
+
+    def prompt_auth_fields(mode)
+      case mode
+      when 'bearer'
+        { 'bearer_token' => ask_secret('Bearer token:') }
+      when 'cookie'
+        { 'auth_cookie' => ask_secret('Session cookie (e.g., JSESSIONID=abc; crowd.token_key=xyz):') }
+      when 'mfa_api'
+        prompt_mfa_api_fields
+      when 'mfa_browser'
+        prompt_mfa_browser_fields
+      else
+        { 'email' => ask('Jira email:'), 'token' => ask_secret('Jira API token:') }
+      end
+    end
+
+    private
+
+    def prompt_mfa_api_fields
+      field = ask('Token field in login response (default: access_token):').strip
+      { 'email' => ask('Jira email:'),
+        'password' => ask_secret('Password:'),
+        'totp_secret' => ask_secret('TOTP secret (base32):'),
+        'mfa_login_url' => ask('MFA API login URL:'),
+        'mfa_token_field' => field.empty? ? 'access_token' : field }
+    end
+
+    def prompt_mfa_browser_fields
+      port = ask('Callback port for local server (leave blank for manual-paste mode):').strip
+      data = { 'idp_login_url' => ask('IdP login URL:') }
+      data['idp_callback_port'] = Integer(port) unless port.empty?
+      data
+    end
+  end
+end