fun_ci 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bacc0733c3648d5b5422304a7c319be52f1531e98f1c802e4a3d2a5280928ba9
-  data.tar.gz: '097d7eaea4e663259c0b745724e6a4d281af1aa60b0ebb3bd78a14c8add5bb57'
+  metadata.gz: 432ab6458948397326b4ee6e80846066d59d3548e54a3a3d189f42740562e613
+  data.tar.gz: 8da12eaeb1c172b64825a2d9c214c56143e47a9d82ba7b5054091662fa8edce1
 SHA512:
-  metadata.gz: feb14f7ff5ba1b67c66b3aa9cddeb9a160320aab302abf9aa60f3cb58b88395e0493abd50dd44db2ddd4030680d0a3c77e99f50cd7408309fe7e3cec9f692163
-  data.tar.gz: 8c3cf91d027932fbb998bb3f341cfced2752de43d926a10310f1900ce672de041f75b830379c665b3286daf93bb0c0b0364af47ba1dd116af8c1cc393481ea85
+  metadata.gz: e1de07fd9136f7648663a57832d31197435343c6c599c8b77c17e06a72b94a7d4a021205810944e0f3ccae4257bc440138bf2ffdc775f569dd7bc323c532c23e
+  data.tar.gz: 1a92c980274f3ff0040429ae5efc4b124f1c8b6706d49a2993d1d27f03fc9211d1b8475c81a7a30a8d37cb5b611fbb46d8dd5a90bbcac2a4672b0fbc600eaee3

data/CHANGELOG.md

@@ -5,6 +5,21 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.1.0] - 2026-02-22
+
+### Added
+- Multi-line ASCII art header animations for pipeline events (explosion on failure, celebrations on success)
+- Looping idle starfield animation in the TUI header
+- Rocket animation while pipelines are running, with flickering exhaust and parallax starfield
+- HeaderAnimationManager with idle/running/event state transitions
+- AnimationLibrary with 8 animation data files (explosion, success, celebrate, flash, leprechauns, yay, idle, running)
+
+### Fixed
+- Footer animations now display 8x slower so text is actually readable
+- Animation refresh no longer blocks for 5 seconds between frames when no pipelines are running
+- Removed stale single-line header banner that conflicted with multi-line animations
+- Animation frames padded to global max width across all frames, preventing horizontal jitter
+
 ## [1.0.0] - 2026-02-21
 
 ### Added

data/README.md

@@ -74,7 +74,9 @@ After `fun-ci install-hooks`, two hooks are active:
 fun-ci console
 ```
 
-Opens a terminal UI showing pipeline status across all branches. Navigation:
+Opens a terminal UI showing pipeline status across all branches. The header area displays animated ASCII art: a gentle starfield when idle, a rocket while pipelines run, and celebration/explosion animations on success or failure.
+
+Navigation:
 
 - `j` / `k` -- scroll up/down
 - `c` -- cancel a running pipeline

data/exe/fun-ci-tui

@@ -3,6 +3,7 @@
 
 require_relative "../lib/fun_ci"
 require_relative "../lib/fun_ci/admin_tui"
+require_relative "../lib/fun_ci/animation_renderer"
 
 require "tmpdir"
 require "io/console"
@@ -14,5 +15,9 @@ db_path = File.join(db_dir, "db.sqlite3")
 db = FunCi::Database.connection(db_path)
 FunCi::Database.migrate!(db)
 
-tui = FunCi::AdminTui.new(db: db, width_provider: -> { IO.console&.winsize&.dig(1) || 80 })
+tui = FunCi::AdminTui.new(
+  db: db,
+  width_provider: -> { IO.console&.winsize&.dig(1) || 80 },
+  animation_renderer: FunCi::AnimationRenderer.new
+)
 tui.run

data/lib/fun_ci/admin_tui.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "board_data"
+require_relative "header_animation_manager"
 require_relative "row_formatter"
 require_relative "screen"
 require_relative "spinner"
@@ -11,11 +12,13 @@ module FunCi
   class AdminTui
     FAST_REFRESH = 0.1  # seconds (spinner + timer)
     SLOW_REFRESH = 5.0  # seconds (settled board)
+    HEADER_HEIGHT = HeaderAnimationManager::HEADER_HEIGHT
 
-    def initialize(db:, output: $stdout, input: $stdin, width: 80, width_provider: nil, page_size: nil)
+    def initialize(db:, output: $stdout, input: $stdin, width: 80,
+                   width_provider: nil, page_size: nil, animation_renderer: nil)
       @board_data = BoardData.new(db, page_size: page_size)
       @screen = Screen.new(output: output, width: width)
-      @output = output
+      @animation_renderer = animation_renderer
       @input = input
       @width_provider = width_provider
       @spinner = Spinner.new
@@ -31,7 +34,7 @@ module FunCi
       streak_text = StreakCounter.format_text(streak)
 
       @screen.render_header(streak_text: streak_text)
-      @screen.println
+      (HEADER_HEIGHT - 1).times { @screen.println }
 
       if runs.empty?
         @screen.render_empty_state
@@ -44,6 +47,7 @@ module FunCi
       end
 
       @screen.clear_below
+      render_animations(runs)
     end
 
     def run
@@ -96,6 +100,12 @@ module FunCi
 
     private
 
+    def render_animations(runs)
+      return unless @animation_renderer
+
+      @animation_renderer.render(@screen, runs)
+    end
+
     def format_run(run)
       opts = {}
       if run[:status] == "running"
@@ -115,6 +125,8 @@ module FunCi
     end
 
     def refresh_interval
+      return FAST_REFRESH if @animation_renderer
+
       runs = @board_data.runs
       any_running = runs.any? { |r| r[:status] == "running" }
       any_running ? FAST_REFRESH : SLOW_REFRESH

data/lib/fun_ci/animation.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module FunCi
+  class Animation
+    TYPES = {
+      failure: { total_frames: 40, priority: 3 },
+      timeout: { total_frames: 4, priority: 2 },
+      success: { total_frames: 40, priority: 1 },
+      stage_pass: { total_frames: 3, priority: 0 }
+    }.freeze
+
+    attr_reader :type, :run_id, :stage, :frame
+
+    def initialize(type:, run_id:, stage: nil)
+      raise ArgumentError, "Unknown animation type: #{type}" unless TYPES.key?(type)
+
+      @type = type
+      @run_id = run_id
+      @stage = stage
+      @frame = 0
+    end
+
+    def advance!
+      @frame += 1
+    end
+
+    def finished?
+      frame >= total_frames
+    end
+
+    def total_frames
+      TYPES[@type][:total_frames]
+    end
+
+    def priority
+      TYPES[@type][:priority]
+    end
+
+    def has_header?
+      %i[failure timeout success].include?(@type)
+    end
+
+    def has_footer?
+      %i[failure success].include?(@type)
+    end
+  end
+end

data/lib/fun_ci/animation_compositor.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative "ansi"
+require_relative "animation_frames"
+require_relative "row_formatter"
+require_relative "duration_formatter"
+
+module FunCi
+  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

data/lib/fun_ci/animation_frames.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative "ansi"
+
+module FunCi
+  module AnimationFrames
+    RESET = Ansi::RESET
+    FOOTER_HOLD = 8
+
+    def self.failure_particles
+      # Left/right flanking debris per frame (chars expanding outward)
+      [
+        { 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

data/lib/fun_ci/animation_library.rb

@@ -0,0 +1,44 @@
+# 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 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

data/lib/fun_ci/animation_renderer.rb

@@ -0,0 +1,142 @@
+# 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
+  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