fun_ci 1.0.0 → 1.2.0

data/lib/fun_ci/tui/animation_library.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "../animations/explosion"
+require_relative "../animations/success"
+require_relative "../animations/celebrate"
+require_relative "../animations/flash"
+require_relative "../animations/leprechauns"
+require_relative "../animations/yay"
+require_relative "../animations/idle"
+require_relative "../animations/running"
+
+module FunCi
+  module Tui
+    module AnimationLibrary
+      FAILURE = [Animations::Explosion::DATA].freeze
+
+      SUCCESS = [
+        Animations::Success::DATA,
+        Animations::Celebrate::DATA,
+        Animations::Flash::DATA,
+        Animations::Leprechauns::DATA,
+        Animations::Yay::DATA
+      ].freeze
+
+      IDLE = Animations::Idle::DATA
+
+      RUNNING = Animations::Running::DATA
+
+      def self.random_failure
+        FAILURE.sample
+      end
+
+      def self.random_success
+        SUCCESS.sample
+      end
+
+      def self.idle
+        IDLE
+      end
+
+      def self.running
+        RUNNING
+      end
+    end
+  end
+end

data/lib/fun_ci/tui/animation_renderer.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require_relative "animation"
+require_relative "animation_compositor"
+require_relative "animation_library"
+require_relative "header_animation_manager"
+require_relative "stage_change_detector"
+
+module FunCi
+  module Tui
+    class AnimationRenderer
+      HEADER_HEIGHT = HeaderAnimationManager::HEADER_HEIGHT
+
+      def initialize(animation_library: AnimationLibrary)
+        @previous_runs = []
+        @animations = []
+        @header_manager = HeaderAnimationManager.new(animation_library: animation_library)
+      end
+
+      def render(screen, runs)
+        detect_and_queue(runs)
+
+        screen.save_cursor
+        render_header_overlay(screen)
+        render_stage_overlays(screen, runs)
+        render_footer_overlay(screen, runs)
+        screen.restore_cursor
+
+        advance_all
+        expire_finished
+      end
+
+      def any_active?
+        @animations.any? { |a| !a.finished? } || @header_manager.any_active_event?
+      end
+
+      def active_count
+        @animations.count { |a| !a.finished? }
+      end
+
+      private
+
+      def detect_and_queue(runs)
+        changes = StageChangeDetector.detect(@previous_runs, runs)
+        @previous_runs = snapshot(runs)
+        changes.each { |change| queue_animation(change, runs) }
+        update_running_state(runs)
+      end
+
+      def update_running_state(runs)
+        any_running = runs.any? { |r| r[:status] == "running" }
+        any_running ? @header_manager.start_running : @header_manager.stop_running
+      end
+
+      def queue_animation(change, runs)
+        run_status = runs.find { |r| r[:id] == change.run_id }&.dig(:status)
+
+        case change.to
+        when "failed"
+          add_animation(:failure, change.run_id, change.stage)
+          @header_manager.trigger_failure
+        when "timed_out"
+          add_animation(:timeout, change.run_id, change.stage)
+        when "completed"
+          if run_status == "completed"
+            add_animation(:success, change.run_id, change.stage)
+            @header_manager.trigger_success
+          else
+            add_animation(:stage_pass, change.run_id, change.stage)
+          end
+        end
+      end
+
+      def add_animation(type, run_id, stage)
+        @animations.reject! do |a|
+          a.type == type && a.run_id == run_id && a.stage == stage
+        end
+        @animations << Animation.new(type: type, run_id: run_id, stage: stage)
+      end
+
+      def render_header_overlay(screen)
+        @header_manager.current_lines(screen.width).each_with_index do |line, i|
+          screen.write_at(1 + i, 1, line)
+        end
+      end
+
+      def render_footer_overlay(screen, runs)
+        anim = highest_priority(:has_footer?)
+        return unless anim
+
+        footer_row = HEADER_HEIGHT + (runs.length * 2) + 1
+        overlay = AnimationCompositor.footer_overlay(anim, screen.width)
+        screen.write_at(footer_row, 1, "#{overlay}\e[K") if overlay
+      end
+
+      def render_stage_overlays(screen, runs)
+        @animations.each do |anim|
+          next if anim.finished?
+
+          run_index = runs.index { |r| r[:id] == anim.run_id }
+          next unless run_index
+
+          row = HEADER_HEIGHT + 1 + (run_index * 2)
+          run = runs[run_index]
+          text = AnimationCompositor.stage_text_for(run, anim.stage)
+          next unless text
+
+          overlay = AnimationCompositor.stage_column_overlay(anim, text, 0)
+          next unless overlay
+
+          col = AnimationCompositor.stage_col_for(run, anim.stage)
+          screen.write_at(row, col, overlay) if col
+        end
+      end
+
+      def highest_priority(predicate)
+        @animations
+          .select { |a| a.send(predicate) && !a.finished? }
+          .max_by(&:priority)
+      end
+
+      def advance_all
+        @animations.each { |a| a.advance! unless a.finished? }
+        @header_manager.advance!
+      end
+
+      def expire_finished
+        @animations.reject!(&:finished?)
+        @header_manager.expire_if_finished!
+      end
+
+      def snapshot(runs)
+        runs.map do |r|
+          {
+            id: r[:id],
+            stages: (r[:stages] || []).map do |s|
+              { stage: s[:stage], status: s[:status] }
+            end
+          }
+        end
+      end
+    end
+  end
+end

data/lib/fun_ci/tui/ansi.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Tui
+    module Ansi
+      RESET = "\e[0m"
+
+      def self.green(text)      = "\e[32m#{text}#{RESET}"
+      def self.bold_green(text)  = "\e[1;32m#{text}#{RESET}"
+      def self.bold_red(text)    = "\e[1;31m#{text}#{RESET}"
+      def self.bold_yellow(text) = "\e[1;33m#{text}#{RESET}"
+      def self.cyan(text)        = "\e[36m#{text}#{RESET}"
+      def self.bold_cyan(text)   = "\e[1;36m#{text}#{RESET}"
+      def self.dim(text)         = "\e[2m#{text}#{RESET}"
+      def self.bold_white(text)  = "\e[1;37m#{text}#{RESET}"
+      def self.white(text)       = "\e[37m#{text}#{RESET}"
+      def self.yellow(text)      = "\e[33m#{text}#{RESET}"
+      def self.dim_green(text)   = "\e[2;32m#{text}#{RESET}"
+      def self.dim_red(text)     = "\e[2;31m#{text}#{RESET}"
+      def self.orange(text)      = "\e[38;5;208m#{text}#{RESET}"
+      def self.dark_red(text)    = "\e[38;5;52m#{text}#{RESET}"
+      def self.bg_charcoal(text) = "\e[48;5;236m#{text}#{RESET}"
+      def self.bg_dark_red(text)    = "\e[48;5;124m#{text}#{RESET}"
+      def self.bg_orange(text)      = "\e[48;5;166m#{text}#{RESET}"
+      def self.bg_very_dark_red(text) = "\e[48;5;52m#{text}#{RESET}"
+      def self.bg_dark_green(text)  = "\e[48;5;22m#{text}#{RESET}"
+      def self.bg_dark_yellow(text) = "\e[48;5;58m#{text}#{RESET}"
+
+      def self.strip(text)
+        text.gsub(/\e\[[0-9;]*[A-Za-z]/, "")
+      end
+    end
+  end
+end

data/lib/fun_ci/tui/board_data.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "time"
+require_relative "../persistence/pipeline_run"
+require_relative "../persistence/stage_job"
+require_relative "streak_counter"
+
+module FunCi
+  module Tui
+    class BoardData
+      def initialize(db, limit: 15, page_size: nil)
+        @db = db
+        @page_size = page_size || limit
+        @limit = @page_size
+      end
+
+      def load_more
+        @limit += @page_size
+      end
+
+      def runs
+        pipeline_runs = Persistence::PipelineRun.recent(@db, limit: @limit)
+        pipeline_runs.map { |run| enrich_with_stages(run) }
+      end
+
+      def streak
+        pipeline_runs = Persistence::PipelineRun.recent(@db, limit: @limit)
+        StreakCounter.count(pipeline_runs)
+      end
+
+      def cancel_run(run_id)
+        Persistence::PipelineRun.update_status(@db, run_id, "cancelled")
+      end
+
+      private
+
+      def enrich_with_stages(run)
+        rows = @db.execute(
+          "SELECT id, pipeline_run_id, stage, status, started_at, completed_at FROM stage_jobs WHERE pipeline_run_id = ? ORDER BY id",
+          [run[:id]]
+        )
+
+        stages = rows.map do |row|
+          job = { id: row[0], pipeline_run_id: row[1], stage: row[2], status: row[3], started_at: row[4], completed_at: row[5] }
+          duration = Persistence::StageJob.elapsed_duration(job)
+          { stage: job[:stage], status: job[:status], duration: duration, started_at: job[:started_at] }
+        end
+
+        run.merge(stages: stages)
+      end
+    end
+  end
+end

data/lib/fun_ci/tui/board_renderer.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative "header_animation_manager"
+require_relative "row_formatter"
+require_relative "streak_counter"
+
+module FunCi
+  module Tui
+    class BoardRenderer
+      HEADER_HEIGHT = HeaderAnimationManager::HEADER_HEIGHT
+
+      def initialize(screen:, spinner:, animation_renderer:, height_provider:)
+        @screen = screen
+        @spinner = spinner
+        @animation_renderer = animation_renderer
+        @height_provider = height_provider
+      end
+
+      def render(runs:, streak:, cursor_index:, confirming:)
+        update_height
+        render_header_area(runs, streak)
+
+        if runs.empty?
+          @screen.render_empty_state
+          @screen.render_footer(empty: true)
+        else
+          rows = runs.map { |run| format_run(run) }
+          rows = truncate_rows_to_height(rows)
+          @screen.render_board(rows, cursor_index: cursor_index)
+          @screen.println unless rows.empty?
+          @screen.render_footer(empty: false, confirming: confirming)
+        end
+
+        @screen.clear_below
+        render_animations(runs)
+      end
+
+      def begin_frame
+        @screen.move_cursor_home
+        @spinner.advance!
+      end
+
+      def clear
+        @screen.clear
+      end
+
+      def resize(new_width)
+        @screen.width = new_width
+      end
+
+      def animation_renderer?
+        !!@animation_renderer
+      end
+
+      private
+
+      def render_header_area(runs, streak)
+        if @animation_renderer
+          @screen.write_at(HEADER_HEIGHT + 1, 1, "")
+        else
+          streak_text = StreakCounter.format_text(streak)
+          @screen.render_header(streak_text: streak_text)
+          (HEADER_HEIGHT - 1).times { @screen.println }
+        end
+      end
+
+      def format_run(run)
+        opts = {}
+        if run[:status] == "running"
+          active_stage = run[:stages].find { |s| s[:status] == "running" }
+          if active_stage && active_stage[:started_at]
+            opts[:elapsed_seconds] = Time.now - Time.parse(active_stage[:started_at])
+          end
+          opts[:spinner_frame] = @spinner.current_frame
+        end
+        RowFormatter.format(run, **opts)
+      end
+
+      def render_animations(runs)
+        return unless @animation_renderer
+
+        @animation_renderer.render(@screen, runs)
+      end
+
+      def update_height
+        return unless @height_provider
+
+        height = @height_provider.call
+        @screen.height = height if height
+      end
+
+      def truncate_rows_to_height(rows)
+        height = @screen.height
+        return rows unless height
+
+        # Line budget: N rows consume 2N-1 lines (row + separator between rows).
+        # Remaining height after header, post-board separator, and footer:
+        #   available = height - HEADER_HEIGHT - 2
+        # Solving 2N - 1 <= available gives N <= (available) / 2.
+        max_rows = [(height - HEADER_HEIGHT - 2) / 2, 0].max
+        rows.first(max_rows)
+      end
+    end
+  end
+end

data/lib/fun_ci/tui/duration_formatter.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Tui
+    module DurationFormatter
+      def self.format(seconds)
+        if seconds >= 60
+          mins = (seconds / 60).to_i
+          secs = (seconds % 60).to_i
+          "#{mins}m#{secs.to_s.rjust(2, "0")}"
+        elsif seconds == seconds.to_i
+          "#{seconds.to_i}s"
+        else
+          "#{format_decimal(seconds)}s"
+        end
+      end
+
+      def self.format_decimal(value)
+        sprintf("%.1f", value)
+      end
+      private_class_method :format_decimal
+    end
+  end
+end

data/lib/fun_ci/tui/header_animation_manager.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "header_animation_player"
+require_relative "looping_animation_player"
+
+module FunCi
+  module Tui
+    class HeaderAnimationManager
+      HEADER_HEIGHT = 14
+
+      def initialize(animation_library:)
+        @idle_player = LoopingAnimationPlayer.new(animation_library.idle)
+        @running_player = nil
+        @header_player = nil
+        @animation_library = animation_library
+      end
+
+      def trigger_failure
+        @header_player = HeaderAnimationPlayer.new(@animation_library.random_failure)
+      end
+
+      def trigger_success
+        @header_player = HeaderAnimationPlayer.new(@animation_library.random_success)
+      end
+
+      def start_running
+        @running_player ||= LoopingAnimationPlayer.new(@animation_library.running)
+      end
+
+      def stop_running
+        @running_player = nil
+      end
+
+      def current_lines(width)
+        lines = active_player.current_lines(width)
+        pad_to_height(lines, HEADER_HEIGHT)
+      end
+
+      def advance!
+        @idle_player.advance!
+        @running_player&.advance!
+        @header_player&.advance!
+      end
+
+      def expire_if_finished!
+        @header_player = nil if @header_player&.finished?
+      end
+
+      def any_active_event?
+        @header_player && !@header_player.finished?
+      end
+
+      private
+
+      def active_player
+        return @header_player if any_active_event?
+        return @running_player if @running_player
+
+        @idle_player
+      end
+
+      def pad_to_height(lines, height)
+        return lines if lines.length >= height
+
+        top_pad = (height - lines.length) / 2
+        blank = "\e[K"
+        Array.new(top_pad, blank) + lines + Array.new(height - lines.length - top_pad, blank)
+      end
+    end
+  end
+end

data/lib/fun_ci/tui/header_animation_player.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "ansi"
+
+module FunCi
+  module Tui
+    class HeaderAnimationPlayer
+      attr_reader :frame
+
+      def initialize(data)
+        @data = data
+        @frame = 0
+      end
+
+      def advance!
+        @frame += 1
+      end
+
+      def finished?
+        @frame >= total_frames
+      end
+
+      def total_frames
+        @data[:frames].length
+      end
+
+      def current_lines(width)
+        return [] if finished?
+
+        frame_lines = @data[:frames][@frame]
+        return [] unless frame_lines
+
+        frame_lines.map { |line| center_line(line, width) }
+      end
+
+      private
+
+      def center_line(line, width)
+        visible_len = Ansi.strip(line).length
+        pad = [(width - visible_len) / 2, 0].max
+        "#{" " * pad}#{line}\e[K"
+      end
+    end
+  end
+end

data/lib/fun_ci/tui/key_handler.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Tui
+    class KeyHandler
+      attr_reader :cursor_index
+
+      def initialize(board_data:)
+        @board_data = board_data
+        @cursor_index = nil
+        @confirm_cancel = nil
+      end
+
+      def handle_key(key)
+        if @confirm_cancel
+          handle_confirm_key(key)
+          return
+        end
+
+        case key
+        when "q"
+          :quit
+        when "j", :down
+          move_cursor_down
+        when "k", :up
+          move_cursor_up
+        when "c"
+          initiate_cancel
+        end
+      end
+
+      def confirming?
+        !@confirm_cancel.nil?
+      end
+
+      def confirmation_run
+        @confirm_cancel
+      end
+
+      private
+
+      def move_cursor_down
+        runs = @board_data.runs
+        return if runs.empty?
+
+        if @cursor_index.nil?
+          @cursor_index = 0
+        elsif @cursor_index < runs.length - 1
+          @cursor_index += 1
+          @board_data.load_more if @cursor_index == runs.length - 1
+        end
+      end
+
+      def move_cursor_up
+        return if @cursor_index.nil?
+
+        @cursor_index -= 1 if @cursor_index > 0
+      end
+
+      def initiate_cancel
+        return if @cursor_index.nil?
+
+        runs = @board_data.runs
+        return if @cursor_index >= runs.length
+
+        run = runs[@cursor_index]
+        case run[:status]
+        when "scheduled"
+          @board_data.cancel_run(run[:id])
+        when "running"
+          @confirm_cancel = run
+        end
+      end
+
+      def handle_confirm_key(key)
+        case key
+        when "y"
+          @board_data.cancel_run(@confirm_cancel[:id])
+          @confirm_cancel = nil
+        when "n", :escape
+          @confirm_cancel = nil
+        end
+      end
+    end
+  end
+end

data/lib/fun_ci/tui/looping_animation_player.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "ansi"
+
+module FunCi
+  module Tui
+    class LoopingAnimationPlayer
+      def initialize(data)
+        @data = data
+        @frame = 0
+      end
+
+      def advance!
+        @frame += 1
+      end
+
+      def frame
+        @frame % total_frames
+      end
+
+      def finished?
+        false
+      end
+
+      def total_frames
+        @data[:frames].length
+      end
+
+      def current_lines(width)
+        frame_lines = @data[:frames][frame]
+        return [] unless frame_lines
+
+        frame_lines.map { |line| center_line(line, width) }
+      end
+
+      private
+
+      def center_line(line, width)
+        visible_len = Ansi.strip(line).length
+        pad = [(width - visible_len) / 2, 0].max
+        "#{" " * pad}#{line}\e[K"
+      end
+    end
+  end
+end

data/lib/fun_ci/tui/relative_time.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "time"
+
+module FunCi
+  module Tui
+    module RelativeTime
+      def self.format(iso_timestamp, now: Time.now)
+        elapsed = now - Time.parse(iso_timestamp)
+        seconds = elapsed.to_i
+
+        if seconds < 60
+          "just now"
+        elsif seconds < 3600
+          "#{seconds / 60}m ago"
+        else
+          "#{seconds / 3600}h ago"
+        end
+      end
+    end
+  end
+end