fun_ci 1.1.0 → 1.2.0

data/lib/fun_ci/tui/animation_compositor.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative "ansi"
+require_relative "animation_frames"
+require_relative "row_formatter"
+require_relative "duration_formatter"
+
+module FunCi
+  module Tui
+    module AnimationCompositor
+      RESET = Ansi::RESET
+      STAGE_STAGGER = { "lint" => 0, "build" => 2, "fast" => 4, "slow" => 6 }.freeze
+
+      def self.header_overlay(animation, width)
+        frames = case animation.type
+                 when :failure then AnimationFrames.failure_header(width)
+                 when :success then AnimationFrames.success_header(width)
+                 when :timeout then AnimationFrames.timeout_header(width)
+                 else return nil
+                 end
+        frame_at(frames, animation.frame)
+      end
+
+      def self.footer_overlay(animation, width)
+        frames = case animation.type
+                 when :failure
+                   AnimationFrames.failure_footer(animation.stage || "stage", width)
+                 when :success then AnimationFrames.success_footer(width)
+                 else return nil
+                 end
+        frame_at(frames, animation.frame)
+      end
+
+      def self.stage_column_overlay(animation, stage_text, col)
+        case animation.type
+        when :stage_pass  then color_flash(animation, stage_text, AnimationFrames.stage_pass_colors)
+        when :timeout     then color_flash(animation, stage_text, AnimationFrames.timeout_colors)
+        when :failure     then failure_flanks(animation, stage_text)
+        when :success     then sparkle_sweep(animation, stage_text)
+        end
+      end
+
+      def self.stage_text_for(run, stage_name)
+        stage = run[:stages]&.find { |s| s[:stage] == stage_name }
+        return nil unless stage
+
+        name = RowFormatter::STAGE_NAMES[stage[:stage]] || stage[:stage]
+        dur = stage[:duration] ? DurationFormatter.format(stage[:duration]) : "--"
+        case stage[:status]
+        when "completed" then "#{name} #{dur}"
+        when "failed"    then "#{name} FAIL #{dur}"
+        when "timed_out" then "#{name} TIMEOUT #{dur}"
+        else "#{name} --"
+        end
+      end
+
+      def self.stage_col_for(run, stage_name)
+        project = run[:project_path] ? "  #{File.basename(run[:project_path])}" : ""
+        prefix_len = 2 + 7 + 2 + run[:branch].to_s.length + project.length + 2
+        (run[:stages] || []).each do |s|
+          return prefix_len + 1 if s[:stage] == stage_name
+          prefix_len += stage_text_for(run, s[:stage]).to_s.length + 2
+        end
+        nil
+      end
+
+      def self.color_flash(animation, stage_text, colors)
+        idx = [animation.frame, colors.length - 1].min
+        "#{colors[idx]}#{Ansi.strip(stage_text)}#{RESET}"
+      end
+      private_class_method :color_flash
+
+      def self.failure_flanks(animation, stage_text)
+        particles = AnimationFrames.failure_particles
+        return nil if animation.frame >= particles.length
+
+        p = particles[animation.frame]
+        plain = Ansi.strip(stage_text)
+        return plain if p[:chars].empty?
+
+        left = p[:chars].reverse
+        right = p[:chars]
+        "#{p[:color]}#{left}#{RESET} #{Ansi.bold_red(plain)} #{p[:color]}#{right}#{RESET}"
+      end
+      private_class_method :failure_flanks
+
+      def self.sparkle_sweep(animation, stage_text)
+        plain = Ansi.strip(stage_text)
+        stagger = STAGE_STAGGER[animation.stage] || 0
+        pos = animation.frame - stagger
+        return nil if pos < 0 || pos > plain.length
+
+        result = plain.chars.map { |c| "\e[32m#{c}" }
+        result[pos] = "\e[1;33m#{plain[pos]}" if pos < plain.length
+        "#{result.join}#{RESET}"
+      end
+      private_class_method :sparkle_sweep
+
+      def self.frame_at(frames, index)
+        return nil if index >= frames.length
+
+        frames[index]
+      end
+      private_class_method :frame_at
+    end
+  end
+end

data/lib/fun_ci/tui/animation_frames.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require_relative "ansi"
+
+module FunCi
+  module Tui
+    module AnimationFrames
+      RESET = Ansi::RESET
+      FOOTER_HOLD = 8
+
+      def self.failure_particles
+        [
+          { chars: "*",     color: "\e[1;31m" },
+          { chars: ".*",    color: "\e[1;31m" },
+          { chars: ".+*.",  color: "\e[38;5;208m" },
+          { chars: "*.+'",  color: "\e[38;5;208m" },
+          { chars: "' .",   color: "\e[38;5;52m" },
+          { chars: ".",     color: "\e[38;5;52m" },
+          { chars: "",      color: "" }
+        ]
+      end
+
+      def self.failure_header(width)
+        boom = "BOOM"
+        [
+          nil,
+          banner(boom, width, "\e[48;5;124m", particles: "* "),
+          banner(boom, width, "\e[48;5;166m", particles: "* * "),
+          banner(boom, width, "\e[48;5;52m",  particles: ". * * "),
+          banner(boom, width, "\e[48;5;236m", particles: "' . * "),
+          banner(boom, width, "\e[48;5;236m", particles: ". "),
+          nil
+        ]
+      end
+
+      def self.failure_footer(stage_name, width)
+        up = stage_name.upcase
+        down = stage_name.downcase
+        hold [
+          nil,
+          center("\e[1;31m>>> #{up} FAILED <<<#{RESET}", ">>> #{up} FAILED <<<", width),
+          center("\e[31m>> #{down} failed <<#{RESET}", ">> #{down} failed <<", width),
+          center("\e[2;31m> #{down} failed <#{RESET}", "> #{down} failed <", width),
+          nil
+        ]
+      end
+
+      def self.success_header(width)
+        text = "ALL PASSED"
+        [
+          nil,
+          banner(text, width, "\e[48;5;22m",  particles: ""),
+          banner(text, width, "\e[48;5;22m",  particles: "*  * "),
+          banner(text, width, "\e[48;5;22m",  particles: "* .  . "),
+          banner(text, width, "\e[48;5;58m",  particles: ". '  ' "),
+          banner(text, width, "\e[48;5;22m",  particles: "' "),
+          banner(text, width, "\e[48;5;22m",  particles: ""),
+          nil
+        ]
+      end
+
+      def self.success_footer(width)
+        hold [
+          nil,
+          center("\e[1;32m* * * NICE! * * *#{RESET}", "* * * NICE! * * *", width),
+          center("\e[32m. + . * NICE! * . + .#{RESET}", ". + . * NICE! * . + .", width),
+          center("\e[2;32m' . + .  nice  . + . '#{RESET}", "' . + .  nice  . + . '", width),
+          nil
+        ]
+      end
+
+      def self.timeout_header(width)
+        [
+          nil,
+          banner("TIMED OUT", width, "\e[48;5;58m", particles: ""),
+          banner("timed out", width, "\e[48;5;58m", particles: ""),
+          nil
+        ]
+      end
+
+      def self.stage_pass_colors
+        ["\e[1;33m", "\e[1;32m", "\e[32m"]
+      end
+
+      def self.timeout_colors
+        ["\e[1;33m", "\e[33m", "\e[1;33m", "\e[33m"]
+      end
+
+      def self.banner(text, width, bg_code, particles: "")
+        padded = if particles.empty?
+                   text.center(width)
+                 else
+                   inner = "#{particles} #{text} #{particles.reverse}"
+                   inner.center(width)
+                 end
+        "#{bg_code}\e[1;37m#{padded}#{RESET}"
+      end
+      private_class_method :banner
+
+      def self.hold(frames)
+        frames.flat_map { |f| Array.new(FOOTER_HOLD, f) }
+      end
+      private_class_method :hold
+
+      def self.center(colored_text, plain_text, width)
+        pad = [(width - plain_text.length) / 2, 0].max
+        "#{" " * pad}#{colored_text}"
+      end
+      private_class_method :center
+    end
+  end
+end

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