fun_ci 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 432ab6458948397326b4ee6e80846066d59d3548e54a3a3d189f42740562e613
-  data.tar.gz: 8da12eaeb1c172b64825a2d9c214c56143e47a9d82ba7b5054091662fa8edce1
+  metadata.gz: 8de275f366537fcf143b9dccdd10002a9cbff42632ab7e2549b695b4a3ba6240
+  data.tar.gz: 8723aee6ea508e2f9bf44c59cb717a83a08dc60381f389550f714b0b0f0de722
 SHA512:
-  metadata.gz: e1de07fd9136f7648663a57832d31197435343c6c599c8b77c17e06a72b94a7d4a021205810944e0f3ccae4257bc440138bf2ffdc775f569dd7bc323c532c23e
-  data.tar.gz: 1a92c980274f3ff0040429ae5efc4b124f1c8b6706d49a2993d1d27f03fc9211d1b8475c81a7a30a8d37cb5b611fbb46d8dd5a90bbcac2a4672b0fbc600eaee3
+  metadata.gz: f4122b18c73b6434eedbe7124fa19b79c64b03fce502a34fdc978aa0d97006091477495d6d9ccfe1cb3ca8eba8be0fa9d53341d328a3bd20ecff43e00c482ddc
+  data.tar.gz: fde4e5346d6bb6038ad35137456a6b1188a61c16f75973e9a55e44b73bc751afed551e1ea063a6a58a38adfbde4eefc1919297d870810ec8ddadfabd6106ce38

data/CHANGELOG.md

@@ -5,6 +5,25 @@ 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.2.0] - 2026-02-23
+
+### Bug Fixes
+- Replaced unreliable `Timeout.timeout` with process groups (`pgroup: true`) and `Thread#join` for reliable time budget enforcement on lint/build/fast/slow stages
+- Fixed off-by-one in TUI row truncation that caused the top pipeline row to be hidden behind the header in short terminals
+- Added `Screen#height=` to clear screen on terminal height changes, preventing the header from scrolling off-screen when tmux panes resize
+- Fixed header flicker by skipping `println` when animation is active
+- Allowed null SHA on root commits so pipeline still runs
+- Detected multi-module Gradle projects from `settings.gradle`
+
+### Refactoring
+- Extracted `TerminalInput`, `KeyHandler`, `BoardRenderer` from `AdminTui` (was 257 lines/12 ivars, now 4 focused classes all under 150 lines/4 ivars)
+- Organized flat `lib/fun_ci/` into cohesive module subdirectories: `persistence/`, `pipeline/`, `setup/`, `tui/`
+
+### Internal
+- Extracted shared `ProcessRunner` module for consistent process spawning across stages
+- Updated `BackgroundWrapper` to use `[output, status, timed_out]` triples instead of exception-based timeout signaling
+- Truncated TUI board rows to fit terminal height
+
 ## [1.1.0] - 2026-02-22
 
 ### Added

data/exe/fun-ci-trigger

@@ -2,8 +2,8 @@
 # frozen_string_literal: true
 
 require_relative "../lib/fun_ci"
-require_relative "../lib/fun_ci/trigger"
-require_relative "../lib/fun_ci/pipeline_recorder"
+require_relative "../lib/fun_ci/pipeline/trigger"
+require_relative "../lib/fun_ci/persistence/pipeline_recorder"
 
 require "tmpdir"
 
@@ -11,9 +11,9 @@ db_dir = File.join(Dir.tmpdir, "fun-ci")
 Dir.mkdir(db_dir) unless Dir.exist?(db_dir)
 db_path = File.join(db_dir, "db.sqlite3")
 
-db = FunCi::Database.connection(db_path)
-FunCi::Database.migrate!(db)
+db = FunCi::Persistence::Database.connection(db_path)
+FunCi::Persistence::Database.migrate!(db)
 
-recorder = FunCi::DbRecorder.new(db)
+recorder = FunCi::Persistence::DbRecorder.new(db)
 
-exit FunCi::Trigger.run_from_args(ARGV, recorder: recorder)
+exit FunCi::Pipeline::Trigger.run_from_args(ARGV, recorder: recorder)

data/exe/fun-ci-tui

@@ -2,8 +2,8 @@
 # frozen_string_literal: true
 
 require_relative "../lib/fun_ci"
-require_relative "../lib/fun_ci/admin_tui"
-require_relative "../lib/fun_ci/animation_renderer"
+require_relative "../lib/fun_ci/tui/admin_tui"
+require_relative "../lib/fun_ci/tui/animation_renderer"
 
 require "tmpdir"
 require "io/console"
@@ -12,12 +12,12 @@ db_dir = File.join(Dir.tmpdir, "fun-ci")
 Dir.mkdir(db_dir) unless Dir.exist?(db_dir)
 db_path = File.join(db_dir, "db.sqlite3")
 
-db = FunCi::Database.connection(db_path)
-FunCi::Database.migrate!(db)
+db = FunCi::Persistence::Database.connection(db_path)
+FunCi::Persistence::Database.migrate!(db)
 
-tui = FunCi::AdminTui.new(
+tui = FunCi::Tui::AdminTui.new(
   db: db,
   width_provider: -> { IO.console&.winsize&.dig(1) || 80 },
-  animation_renderer: FunCi::AnimationRenderer.new
+  animation_renderer: FunCi::Tui::AnimationRenderer.new
 )
 tui.run

data/lib/fun_ci/cli.rb

@@ -42,30 +42,31 @@ module FunCi
     end
 
     def run_trigger(args)
-      require_relative "trigger"
-      require_relative "pipeline_recorder"
+      require_relative "pipeline/trigger"
+      require_relative "persistence/pipeline_recorder"
       db = setup_db
-      recorder = DbRecorder.new(db)
-      Trigger.run_from_args(args, stdout: @stdout, stderr: @stderr, recorder: recorder)
+      recorder = Persistence::DbRecorder.new(db)
+      Pipeline::Trigger.run_from_args(args, stdout: @stdout, stderr: @stderr, recorder: recorder)
     end
 
     def run_console(_args)
-      require_relative "admin_tui"
-      require_relative "animation_renderer"
+      require_relative "tui/admin_tui"
+      require_relative "tui/animation_renderer"
       require "io/console"
       db = setup_db
-      tui = AdminTui.new(
+      tui = Tui::AdminTui.new(
         db: db,
         width_provider: -> { IO.console&.winsize&.dig(1) || 80 },
-        animation_renderer: AnimationRenderer.new
+        height_provider: -> { IO.console&.winsize&.dig(0) },
+        animation_renderer: Tui::AnimationRenderer.new
       )
       tui.run
       0
     end
 
     def run_init(args)
-      require_relative "installer"
-      code = Installer.run(project_root: Dir.pwd, stdout: @stdout)
+      require_relative "setup/installer"
+      code = Setup::Installer.run(project_root: Dir.pwd, stdout: @stdout)
       return code if code != 0 || !args.include?("--everything")
       code = run_install_hooks([])
       return code unless code == 0
@@ -73,26 +74,26 @@ module FunCi
     end
 
     def run_install_hooks(args)
-      require_relative "hook_writer"
+      require_relative "setup/hook_writer"
       types = args.any? ? [args.first] : %w[pre-commit pre-push]
       types.each do |type|
-        code = HookWriter.run(project_root: Dir.pwd, hook_type: type, stdout: @stdout)
+        code = Setup::HookWriter.run(project_root: Dir.pwd, hook_type: type, stdout: @stdout)
         return code unless code == 0
       end
       0
     end
 
     def run_check(_args)
-      require_relative "setup_checker"
-      SetupChecker.run(project_root: Dir.pwd, stdout: @stdout, stderr: @stderr)
+      require_relative "setup/setup_checker"
+      Setup::SetupChecker.run(project_root: Dir.pwd, stdout: @stdout, stderr: @stderr)
     end
 
     def setup_db
       db_dir = File.join(Dir.tmpdir, "fun-ci")
       Dir.mkdir(db_dir) unless Dir.exist?(db_dir)
       db_path = File.join(db_dir, "db.sqlite3")
-      db = Database.connection(db_path)
-      Database.migrate!(db)
+      db = Persistence::Database.connection(db_path)
+      Persistence::Database.migrate!(db)
       db
     end
 

data/lib/fun_ci/persistence/database.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "sqlite3"
+
+module FunCi
+  module Persistence
+    module Database
+      def self.connection(db_path)
+        db = SQLite3::Database.new(db_path)
+        db.busy_timeout = 5000
+        db.execute("PRAGMA journal_mode=WAL")
+        db.execute("PRAGMA foreign_keys=ON")
+        db
+      end
+
+      def self.migrate!(db)
+        db.execute(<<~SQL)
+          CREATE TABLE IF NOT EXISTS pipeline_runs (
+            id INTEGER PRIMARY KEY,
+            commit_hash TEXT,
+            branch TEXT,
+            status TEXT DEFAULT 'scheduled',
+            pid INTEGER,
+            created_at TEXT,
+            updated_at TEXT
+          )
+        SQL
+
+        add_column_if_missing(db, "pipeline_runs", "pid", "INTEGER")
+        add_column_if_missing(db, "pipeline_runs", "project_path", "TEXT")
+
+        db.execute(<<~SQL)
+          CREATE TABLE IF NOT EXISTS stage_jobs (
+            id INTEGER PRIMARY KEY,
+            pipeline_run_id INTEGER REFERENCES pipeline_runs(id),
+            stage TEXT,
+            status TEXT DEFAULT 'scheduled',
+            started_at TEXT,
+            completed_at TEXT
+          )
+        SQL
+      end
+
+      def self.add_column_if_missing(db, table, column, type)
+        columns = db.execute("PRAGMA table_info(#{table})").map { |row| row[1] }
+        return if columns.include?(column)
+        db.execute("ALTER TABLE #{table} ADD COLUMN #{column} #{type}")
+      end
+      private_class_method :add_column_if_missing
+    end
+  end
+end

data/lib/fun_ci/persistence/pipeline_recorder.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "pipeline_run"
+require_relative "stage_job"
+
+module FunCi
+  module Persistence
+    class NullRecorder
+      def create_run(commit_hash:, branch:, project_path: nil) = nil
+      def start_stage(stage) = nil
+      def end_stage(job_id, status) = nil
+      def complete_run = nil
+      def fail_run = nil
+      def db = nil
+      def db_path = nil
+      def pipeline_run_id = nil
+      def close = nil
+    end
+
+    class DbRecorder
+      attr_reader :db, :db_path, :pipeline_run_id
+
+      def self.for_background(db_path, pipeline_run_id)
+        db = Database.connection(db_path)
+        new(db, pipeline_run_id: pipeline_run_id)
+      end
+
+      def initialize(db, pipeline_run_id: nil)
+        @db = db
+        @db_path = db.filename("main")
+        @pipeline_run_id = pipeline_run_id
+      end
+
+      def close
+        @db.close rescue nil
+      end
+
+      def create_run(commit_hash:, branch:, project_path: nil)
+        @pipeline_run_id = PipelineRun.create(@db, commit_hash: commit_hash, branch: branch, project_path: project_path)
+      end
+
+      def start_stage(stage)
+        return nil unless @pipeline_run_id
+        ensure_running
+        job_id = StageJob.create(@db, pipeline_run_id: @pipeline_run_id, stage: stage)
+        StageJob.update_status(@db, job_id, "running")
+        job_id
+      end
+
+      def end_stage(job_id, status)
+        return unless job_id
+        StageJob.update_status(@db, job_id, status)
+      end
+
+      def complete_run
+        return unless @pipeline_run_id
+        PipelineRun.update_status(@db, @pipeline_run_id, "completed")
+      end
+
+      def fail_run
+        return unless @pipeline_run_id
+        PipelineRun.update_status(@db, @pipeline_run_id, "failed")
+      end
+
+      private
+
+      def ensure_running
+        run = PipelineRun.find(@db, @pipeline_run_id)
+        return unless run && run[:status] == "scheduled"
+        PipelineRun.update_status(@db, @pipeline_run_id, "running")
+      end
+    end
+  end
+end

data/lib/fun_ci/persistence/pipeline_run.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "time"
+
+module FunCi
+  module Persistence
+    module PipelineRun
+      def self.create(db, commit_hash:, branch:, project_path: nil)
+        now = Time.now.utc.iso8601
+        db.execute(
+          "INSERT INTO pipeline_runs (commit_hash, branch, project_path, status, created_at, updated_at) VALUES (?, ?, ?, 'scheduled', ?, ?)",
+          [commit_hash, branch, project_path, now, now]
+        )
+        db.last_insert_row_id
+      end
+
+      def self.find(db, id)
+        row = db.execute("SELECT id, commit_hash, branch, status, pid, project_path, created_at, updated_at FROM pipeline_runs WHERE id = ?", [id]).first
+        return nil unless row
+        row_to_hash(row)
+      end
+
+      def self.find_by_branch(db, branch)
+        rows = db.execute("SELECT id, commit_hash, branch, status, pid, project_path, created_at, updated_at FROM pipeline_runs WHERE branch = ? ORDER BY id DESC", [branch])
+        rows.map { |row| row_to_hash(row) }
+      end
+
+      def self.find_by_commit(db, commit_hash)
+        rows = db.execute("SELECT id, commit_hash, branch, status, pid, project_path, created_at, updated_at FROM pipeline_runs WHERE commit_hash = ? ORDER BY id DESC", [commit_hash])
+        rows.map { |row| row_to_hash(row) }
+      end
+
+      def self.store_pid(db, id, pid)
+        db.execute("UPDATE pipeline_runs SET pid = ? WHERE id = ?", [pid, id])
+      end
+
+      def self.find_running_with_pid(db, branch)
+        row = db.execute("SELECT id, commit_hash, branch, status, pid, project_path, created_at, updated_at FROM pipeline_runs WHERE branch = ? AND status = 'running' AND pid IS NOT NULL ORDER BY id DESC LIMIT 1", [branch]).first
+        return nil unless row
+        row_to_hash(row)
+      end
+
+      def self.update_status(db, id, new_status)
+        now = Time.now.utc.iso8601
+        db.execute("UPDATE pipeline_runs SET status = ?, updated_at = ? WHERE id = ?", [new_status, now, id])
+      end
+
+      def self.recent(db, limit: 20)
+        rows = db.execute("SELECT id, commit_hash, branch, status, pid, project_path, created_at, updated_at FROM pipeline_runs ORDER BY id DESC LIMIT ?", [limit])
+        rows.map { |row| row_to_hash(row) }
+      end
+
+      def self.row_to_hash(row)
+        { id: row[0], commit_hash: row[1], branch: row[2], status: row[3], pid: row[4], project_path: row[5], created_at: row[6], updated_at: row[7] }
+      end
+      private_class_method :row_to_hash
+    end
+  end
+end

data/lib/fun_ci/persistence/stage_job.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "time"
+
+module FunCi
+  module Persistence
+    module StageJob
+      TERMINAL_STATUSES = %w[completed failed timed_out cancelled].freeze
+
+      def self.create(db, pipeline_run_id:, stage:)
+        db.execute(
+          "INSERT INTO stage_jobs (pipeline_run_id, stage, status) VALUES (?, ?, 'scheduled')",
+          [pipeline_run_id, stage]
+        )
+        db.last_insert_row_id
+      end
+
+      def self.find(db, id)
+        row = db.execute("SELECT id, pipeline_run_id, stage, status, started_at, completed_at FROM stage_jobs WHERE id = ?", [id]).first
+        return nil unless row
+        row_to_hash(row)
+      end
+
+      def self.update_status(db, id, new_status)
+        now = Time.now.utc.iso8601
+        if new_status == "running"
+          db.execute("UPDATE stage_jobs SET status = ?, started_at = ? WHERE id = ?", [new_status, now, id])
+        elsif TERMINAL_STATUSES.include?(new_status)
+          db.execute("UPDATE stage_jobs SET status = ?, completed_at = ? WHERE id = ?", [new_status, now, id])
+        else
+          db.execute("UPDATE stage_jobs SET status = ? WHERE id = ?", [new_status, id])
+        end
+      end
+
+      def self.elapsed_duration(job)
+        return nil unless job[:started_at] && job[:completed_at]
+        Time.parse(job[:completed_at]) - Time.parse(job[:started_at])
+      end
+
+      def self.row_to_hash(row)
+        { id: row[0], pipeline_run_id: row[1], stage: row[2], status: row[3], started_at: row[4], completed_at: row[5] }
+      end
+      private_class_method :row_to_hash
+    end
+  end
+end

data/lib/fun_ci/{state_machine.rb → persistence/state_machine.rb}

@@ -1,18 +1,8 @@
 # frozen_string_literal: true
 
 module FunCi
-  # Enforced state machine for pipeline runs and stage jobs.
-  #
-  # States: scheduled, running, completed, failed, timed_out, cancelled
-  #
-  # Valid transitions:
-  #   scheduled -> running
-  #   scheduled -> cancelled
-  #   running   -> completed
-  #   running   -> failed
-  #   running   -> timed_out
-  #   running   -> cancelled
-  class StateMachine
+  module Persistence
+    class StateMachine
     class InvalidTransition < StandardError; end
 
     STATES = %i[scheduled running completed failed timed_out cancelled].freeze
@@ -55,5 +45,6 @@ module FunCi
 
       raise ArgumentError, "Unknown state: #{state}. Valid states: #{STATES.join(", ")}"
     end
+    end
   end
 end

data/lib/fun_ci/pipeline/background_wrapper.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Pipeline
+    class BackgroundWrapper
+      def initialize(recorder:, job_id:, executor:)
+        @recorder = recorder
+        @job_id = job_id
+        @executor = executor
+      end
+
+      def run
+        _output, status, timed_out = @executor.call
+        if timed_out
+          @recorder.end_stage(@job_id, "timed_out")
+          @recorder.fail_run
+        elsif status.success?
+          @recorder.end_stage(@job_id, "completed")
+          @recorder.complete_run
+        else
+          @recorder.end_stage(@job_id, "failed")
+          @recorder.fail_run
+        end
+      end
+    end
+  end
+end

data/lib/fun_ci/pipeline/pipeline_forker.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "../persistence/database"
+require_relative "../persistence/pipeline_recorder"
+require_relative "background_wrapper"
+
+module FunCi
+  module Pipeline
+    class PipelineForker
+      def self.fork_pipeline(commit_hash:, branch:, db_path:)
+        pid = fork do
+          run_in_child(commit_hash: commit_hash, branch: branch, db_path: db_path)
+        end
+        Process.detach(pid)
+      end
+
+      def self.run_in_child(commit_hash:, branch:, db_path:)
+        db = Persistence::Database.connection(db_path)
+        recorder = Persistence::DbRecorder.new(db)
+        Trigger.new(
+          project_root: Dir.pwd,
+          commit_hash: commit_hash,
+          branch: branch,
+          stdout: File.open(File::NULL, "w"),
+          recorder: recorder,
+          background_launcher: method(:sync_launcher)
+        ).run
+        recorder.close
+      end
+
+      def self.sync_launcher(db_path:, pipeline_run_id:, job_id:, executor:)
+        recorder = Persistence::DbRecorder.for_background(db_path, pipeline_run_id)
+        BackgroundWrapper.new(recorder: recorder, job_id: job_id, executor: executor).run
+        recorder.close
+      end
+    end
+  end
+end

data/lib/fun_ci/pipeline/process_runner.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Pipeline
+    module ProcessRunner
+      def run_process_with_timeout(cmd, budget)
+        r, w = IO.pipe
+        pid = Process.spawn(cmd, out: w, err: w, pgroup: true)
+        w.close
+
+        reader = Thread.new { r.read }
+
+        if reader.join(budget)
+          output = reader.value
+          _, status = Process.waitpid2(pid)
+          [output, status, false]
+        else
+          Process.kill("TERM", -pid) rescue nil
+          Process.kill("KILL", -pid) rescue nil
+          Process.waitpid(pid) rescue nil
+          ["", nil, true]
+        end
+      ensure
+        r&.close rescue nil
+      end
+    end
+  end
+end

data/lib/fun_ci/pipeline/progress_reporter.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Pipeline
+    class ProgressReporter
+      def initialize(stdout:)
+        @stdout = stdout
+      end
+
+      def phase_one_result(results)
+        markers = results.map { |stage, passed| "#{stage} #{result_marker(passed)}" }
+        summary = results.values.all? ? "phase 1 passed" : "phase 1 failed"
+        @stdout.puts "fun-ci: #{markers.join("  ")}  (#{summary})"
+      end
+
+      def fast_result(passed)
+        @stdout.puts "fun-ci: fast #{result_marker(passed)}"
+      end
+
+      def slow_launched
+        @stdout.puts "fun-ci: slow (running in background)"
+      end
+
+      private
+
+      def result_marker(passed)
+        passed ? "ok" : "FAIL"
+      end
+    end
+  end
+end

data/lib/fun_ci/pipeline/stage_runner.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "timeout"
+require_relative "process_runner"
+
+module FunCi
+  module Pipeline
+    class StageRunner
+      include ProcessRunner
+
+      def initialize(commit_hash:, stdout:, command_runner: nil, time_budgets: {}, recorder: FunCi::NullRecorder.new)
+        @commit_hash = commit_hash
+        @stdout = stdout
+        @command_runner = command_runner
+        @time_budgets = time_budgets
+        @recorder = recorder
+      end
+
+      def run_stage(config, stage)
+        script = config.script_path(stage)
+        budget = @time_budgets[stage]
+
+        job_id = @recorder.start_stage(stage)
+        output, status, timed_out = run_with_timeout(script, budget)
+
+        if timed_out
+          @recorder.end_stage(job_id, "timed_out")
+          @stdout.puts "#{stage_label(stage)} killed -- exceeded #{budget}s time budget."
+          @stdout.puts budget_advice(stage)
+          return false
+        end
+
+        unless status.success?
+          @recorder.end_stage(job_id, "failed")
+          @stdout.puts output unless output.empty?
+          @stdout.puts "#{stage_label(stage)} failed."
+          return false
+        end
+
+        @recorder.end_stage(job_id, "completed")
+        true
+      end
+
+      private
+
+      def run_with_timeout(script, budget)
+        cmd = "#{script} #{@commit_hash}"
+
+        if @command_runner
+          begin
+            output, status = @command_runner.call(cmd)
+            [output, status, false]
+          rescue Timeout::Error
+            ["", nil, true]
+          end
+        else
+          run_process_with_timeout(cmd, budget)
+        end
+      end
+
+      def stage_label(stage)
+        case stage
+        when "lint" then "Lint"
+        when "build" then "Build"
+        when "fast" then "Fast suite"
+        when "slow" then "Slow suite"
+        else stage
+        end
+      end
+
+      def budget_advice(stage)
+        case stage
+        when "lint"
+          "Trim your linter config or split into stages."
+        when "build"
+          "Keep your build efficient and not let it become a bottleneck."
+        when "fast"
+          "Your fast tests have gotten too slow. Split or speed them up."
+        when "slow"
+          "Pare down integration tests, parallelise, or raise the budget."
+        end
+      end
+    end
+  end
+end