fun_ci 1.1.0 → 1.2.0

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

data/lib/fun_ci/tui/row_formatter.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require_relative "ansi"
+require_relative "duration_formatter"
+require_relative "relative_time"
+
+module FunCi
+  module Tui
+    module RowFormatter
+      STAGE_NAMES = { "lint" => "Lint", "build" => "Build", "fast" => "Fast", "slow" => "Slow" }.freeze
+      STATUS_LABELS = {
+        "completed" => "PASSED", "failed" => "FAILED", "timed_out" => "TIMED OUT",
+        "running" => "RUNNING", "scheduled" => "Scheduled...", "cancelled" => "CANCELLED"
+      }.freeze
+      PROJECT_COLORS = %w[31 32 33 34 35 36 91 92 93 94].freeze
+
+      def self.format(run, now: Time.now, spinner_frame: nil, elapsed_seconds: nil)
+        commit = run[:commit_hash][0, 7]
+        branch = run[:branch]
+        status = run[:status]
+        project = format_project(run[:project_path])
+
+        case status
+        when "scheduled"
+          format_scheduled(commit, branch, project, run[:updated_at], now)
+        when "cancelled"
+          format_cancelled(commit, branch, project, run[:stages], run[:updated_at], now)
+        else
+          stages_text = format_stages(run[:stages], status, spinner_frame, elapsed_seconds)
+          status_text = format_status(status)
+          time_text = Ansi.dim(RelativeTime.format(run[:updated_at], now: now))
+          "  #{commit}  #{branch}#{project}  #{stages_text}  #{status_text}  #{time_text}"
+        end
+      end
+
+      def self.format_project(project_path)
+        return "" unless project_path
+        name = File.basename(project_path)
+        code = PROJECT_COLORS[name.hash.abs % PROJECT_COLORS.size]
+        "  \e[#{code}m#{name}#{Ansi::RESET}"
+      end
+      private_class_method :format_project
+
+      def self.format_scheduled(commit, branch, project, updated_at, now)
+        time_text = RelativeTime.format(updated_at, now: now)
+        Ansi.dim("  #{commit}  #{branch}#{project}  Scheduled...  #{time_text}")
+      end
+      private_class_method :format_scheduled
+
+      def self.format_cancelled(commit, branch, project, stages, updated_at, now)
+        stages_text = stages.map { |s| format_cancelled_stage(s) }.join("  ")
+        time_text = RelativeTime.format(updated_at, now: now)
+        Ansi.dim("  #{commit}  #{branch}#{project}  #{stages_text}  CANCELLED  #{time_text}")
+      end
+      private_class_method :format_cancelled
+
+      def self.format_cancelled_stage(stage)
+        name = STAGE_NAMES[stage[:stage]]
+        if stage[:duration]
+          "#{name} #{DurationFormatter.format(stage[:duration])}"
+        else
+          "#{name} --"
+        end
+      end
+      private_class_method :format_cancelled_stage
+
+      def self.format_stages(stages, run_status, spinner_frame, elapsed_seconds)
+        stages.map { |s| format_stage(s, spinner_frame, elapsed_seconds) }.join("  ")
+      end
+      private_class_method :format_stages
+
+      def self.format_stage(stage, spinner_frame, elapsed_seconds)
+        name = STAGE_NAMES[stage[:stage]]
+
+        case stage[:status]
+        when "completed"
+          time = DurationFormatter.format(stage[:duration])
+          Ansi.green("#{name} #{time}")
+        when "failed"
+          time = DurationFormatter.format(stage[:duration])
+          Ansi.bold_red("#{name} FAIL #{time}")
+        when "timed_out"
+          time = DurationFormatter.format(stage[:duration])
+          Ansi.bold_yellow("#{name} TIMEOUT #{time}")
+        when "running"
+          frame = spinner_frame || "\u2800"
+          time = elapsed_seconds ? "#{elapsed_seconds.to_i}s" : "--"
+          Ansi.cyan("#{name} #{frame} #{time}")
+        else
+          Ansi.dim("#{name} --")
+        end
+      end
+      private_class_method :format_stage
+
+      def self.format_status(status)
+        label = STATUS_LABELS[status]
+        case status
+        when "completed" then Ansi.bold_green(label)
+        when "failed"    then Ansi.bold_red(label)
+        when "timed_out" then Ansi.bold_yellow(label)
+        when "running"   then Ansi.bold_cyan(label)
+        else Ansi.dim(label)
+        end
+      end
+      private_class_method :format_status
+    end
+  end
+end

data/lib/fun_ci/tui/screen.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative "ansi"
+
+module FunCi
+  module Tui
+    class Screen
+      attr_reader :width, :height
+
+      def initialize(output: $stdout, width: 80)
+        @output = output
+        @width = width
+      end
+
+      def width=(new_width)
+        return if new_width == @width
+
+        clear
+        @width = new_width
+      end
+
+      def height=(new_height)
+        return if new_height == @height
+
+        clear
+        @height = new_height
+      end
+
+      def render_header(streak_text:)
+        title = " fun-ci"
+        if streak_text
+          streak_display = Ansi.green(streak_text)
+          plain_streak = streak_text
+          padding = @width - title.length - plain_streak.length
+          padding = 1 if padding < 1
+          line = "#{title}#{" " * padding}#{streak_display}"
+        else
+          line = title.ljust(@width)
+        end
+        println Ansi.bg_charcoal(Ansi.white(line))
+      end
+
+      def render_footer(empty: false, confirming: false)
+        if confirming
+          println Ansi.dim("  Cancel running pipeline? y/n")
+        elsif empty
+          println Ansi.dim("  q quit")
+        else
+          println Ansi.dim("  j/k move   c cancel   q quit")
+        end
+      end
+
+      def render_empty_state
+        println ""
+        println ""
+        println "          No runs yet."
+        println ""
+        println "          Trigger one:  fun-ci trigger HEAD"
+        println "          Or hook it:   fun-ci install-hook pre-push"
+        println ""
+      end
+
+      def render_board(rows, cursor_index:)
+        rows.each_with_index do |row, i|
+          if cursor_index == i
+            println "> #{row.lstrip}"
+          else
+            println row
+          end
+          println unless i == rows.length - 1
+        end
+      end
+
+      def println(text = "")
+        @output.print "#{text}\e[K\r\n"
+      end
+
+      def clear
+        @output.print "\e[2J\e[H"
+      end
+
+      def move_cursor_home
+        @output.print "\e[H"
+      end
+
+      def clear_below
+        @output.print "\e[J"
+      end
+
+      def write_at(row, col, text)
+        @output.print "\e[#{row};#{col}H#{text}"
+      end
+
+      def save_cursor
+        @output.print "\e[s"
+      end
+
+      def restore_cursor
+        @output.print "\e[u"
+      end
+    end
+  end
+end

data/lib/fun_ci/tui/spinner.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Tui
+    class Spinner
+      BRAILLE_FRAMES = %W[\u2800 \u2801 \u2803 \u2807 \u280F \u281F \u283F \u287F].freeze
+
+      attr_reader :frames
+
+      def initialize
+        @frames = BRAILLE_FRAMES
+        @index = 0
+      end
+
+      def current_frame
+        @frames[@index]
+      end
+
+      def advance!
+        @index = (@index + 1) % @frames.length
+      end
+    end
+  end
+end

data/lib/fun_ci/tui/stage_change_detector.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Tui
+    module StageChangeDetector
+      Change = Data.define(:run_id, :stage, :from, :to)
+
+      def self.detect(previous_runs, current_runs)
+        return [] if previous_runs.empty?
+
+        current_by_id = index_by_id(current_runs)
+        changes = []
+
+        previous_runs.each do |prev_run|
+          cur_run = current_by_id[prev_run[:id]]
+          next unless cur_run
+
+          changes.concat(compare_stages(prev_run, cur_run))
+        end
+
+        changes
+      end
+
+      def self.index_by_id(runs)
+        runs.each_with_object({}) { |r, h| h[r[:id]] = r }
+      end
+      private_class_method :index_by_id
+
+      def self.compare_stages(prev_run, cur_run)
+        prev_stages = index_stages(prev_run[:stages])
+        changes = []
+
+        cur_run[:stages].each do |cur_stage|
+          prev_stage = prev_stages[cur_stage[:stage]]
+          prev_status = prev_stage ? prev_stage[:status] : nil
+          next if prev_status == cur_stage[:status]
+
+          changes << Change.new(
+            run_id: cur_run[:id],
+            stage: cur_stage[:stage],
+            from: prev_status,
+            to: cur_stage[:status]
+          )
+        end
+
+        changes
+      end
+      private_class_method :compare_stages
+
+      def self.index_stages(stages)
+        return {} unless stages
+
+        stages.each_with_object({}) { |s, h| h[s[:stage]] = s }
+      end
+      private_class_method :index_stages
+    end
+  end
+end

data/lib/fun_ci/tui/streak_counter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Tui
+    module StreakCounter
+      PASS_STATUS = "completed"
+      ACTIVE_STATUSES = %w[running scheduled].freeze
+
+      def self.count(runs)
+        terminal_runs = runs.reject { |r| ACTIVE_STATUSES.include?(r[:status]) }
+        return nil if terminal_runs.empty?
+
+        streak = 0
+        terminal_runs.each do |run|
+          break unless run[:status] == PASS_STATUS
+          streak += 1
+        end
+        streak
+      end
+
+      def self.format_text(streak)
+        return nil if streak.nil?
+        return "Streak broken" if streak == 0
+
+        "#{streak} in a row!"
+      end
+    end
+  end
+end

data/lib/fun_ci/tui/terminal_input.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Tui
+    class TerminalInput
+      def initialize(input:, width_provider: nil)
+        @input = input
+        @width_provider = width_provider
+        @signal_read = nil
+        @signal_write = nil
+      end
+
+      def setup_signal_trap
+        return unless @width_provider
+
+        @signal_read, @signal_write = IO.pipe
+        Signal.trap("WINCH") do
+          @signal_write&.write_nonblock(".") rescue nil # rubocop:disable Style/RescueModifier
+        end
+      end
+
+      def check_width
+        return nil unless @width_provider
+
+        @width_provider.call
+      end
+
+      def setup_raw_mode
+        @input.raw! if @input.respond_to?(:raw!)
+      rescue Errno::ENOTTY
+        # Not a terminal (testing)
+      end
+
+      def restore_terminal
+        @input.cooked! if @input.respond_to?(:cooked!)
+      rescue Errno::ENOTTY
+        # Not a terminal
+      end
+
+      def read_key_with_timeout(timeout)
+        return nil unless @input.respond_to?(:read_nonblock)
+
+        watched = [@input]
+        watched << @signal_read if @signal_read
+        ready = IO.select(watched, nil, nil, timeout)
+        return nil unless ready
+
+        if @signal_read && ready[0].include?(@signal_read)
+          @signal_read.read_nonblock(1) rescue nil # rubocop:disable Style/RescueModifier
+          return nil unless ready[0].include?(@input)
+        end
+
+        byte = @input.read_nonblock(1)
+        if byte == "\e"
+          seq = @input.read_nonblock(2) rescue "" # rubocop:disable Style/RescueModifier
+          case seq
+          when "[A" then :up
+          when "[B" then :down
+          else :escape
+          end
+        else
+          byte
+        end
+      rescue IO::WaitReadable, EOFError
+        nil
+      end
+    end
+  end
+end

data/lib/fun_ci.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require_relative "fun_ci/database"
-require_relative "fun_ci/state_machine"
-require_relative "fun_ci/pipeline_run"
-require_relative "fun_ci/stage_job"
-require_relative "fun_ci/project_config"
+require_relative "fun_ci/persistence/database"
+require_relative "fun_ci/persistence/state_machine"
+require_relative "fun_ci/persistence/pipeline_run"
+require_relative "fun_ci/persistence/stage_job"
+require_relative "fun_ci/setup/project_config"
 
 module FunCi
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 
   BUILD_TIMEOUT = 30
   FAST_SUITE_TIMEOUT = 10