fun_ci 1.0.0 → 1.2.0

data/lib/fun_ci/admin_tui.rb

@@ -1,226 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "board_data"
-require_relative "row_formatter"
-require_relative "screen"
-require_relative "spinner"
-require_relative "streak_counter"
-require "io/console"
-
-module FunCi
-  class AdminTui
-    FAST_REFRESH = 0.1  # seconds (spinner + timer)
-    SLOW_REFRESH = 5.0  # seconds (settled board)
-
-    def initialize(db:, output: $stdout, input: $stdin, width: 80, width_provider: nil, page_size: nil)
-      @board_data = BoardData.new(db, page_size: page_size)
-      @screen = Screen.new(output: output, width: width)
-      @output = output
-      @input = input
-      @width_provider = width_provider
-      @spinner = Spinner.new
-      @cursor_index = nil
-      @running = false
-      @confirm_cancel = nil
-    end
-
-    def render_once
-      update_width_from_provider
-      runs = @board_data.runs
-      streak = @board_data.streak
-      streak_text = StreakCounter.format_text(streak)
-
-      @screen.render_header(streak_text: streak_text)
-      @screen.println
-
-      if runs.empty?
-        @screen.render_empty_state
-        @screen.render_footer(empty: true)
-      else
-        rows = runs.map { |run| format_run(run) }
-        @screen.render_board(rows, cursor_index: @cursor_index)
-        @screen.println
-        @screen.render_footer(empty: false, confirming: confirming?)
-      end
-
-      @screen.clear_below
-    end
-
-    def run
-      @running = true
-      @screen.clear
-
-      begin
-        setup_raw_mode
-        setup_sigwinch_trap
-        loop do
-          render_frame
-          break unless @running
-          key = read_key_with_timeout(refresh_interval)
-          handle_key(key) if key
-        end
-      ensure
-        restore_terminal
-      end
-    end
-
-    def resize(new_width)
-      @screen.width = new_width
-    end
-
-    def confirming?
-      !@confirm_cancel.nil?
-    end
-
-    def confirmation_run
-      @confirm_cancel
-    end
-
-    def handle_key(key)
-      if @confirm_cancel
-        handle_confirm_key(key)
-        return
-      end
-
-      case key
-      when "q"
-        @running = false
-      when "j", :down
-        move_cursor_down
-      when "k", :up
-        move_cursor_up
-      when "c"
-        initiate_cancel
-      end
-    end
-
-    private
-
-    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_frame
-      @screen.move_cursor_home
-      @spinner.advance!
-      render_once
-    end
-
-    def refresh_interval
-      runs = @board_data.runs
-      any_running = runs.any? { |r| r[:status] == "running" }
-      any_running ? FAST_REFRESH : SLOW_REFRESH
-    end
-
-    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?
-
-      if @cursor_index > 0
-        @cursor_index -= 1
-      end
-    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
-
-    def update_width_from_provider
-      return unless @width_provider
-
-      new_width = @width_provider.call
-      resize(new_width) if new_width
-    end
-
-    def setup_sigwinch_trap
-      return unless @width_provider
-
-      @signal_read, @signal_write = IO.pipe
-      Signal.trap("WINCH") do
-        @signal_write.write_nonblock(".") rescue nil
-      end
-    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
-
-      # Drain signal pipe if it woke us
-      if @signal_read && ready[0].include?(@signal_read)
-        @signal_read.read_nonblock(1) rescue nil
-        return nil unless ready[0].include?(@input)
-      end
-
-      byte = @input.read_nonblock(1)
-      if byte == "\e"
-        # Escape sequence
-        seq = @input.read_nonblock(2) rescue ""
-        case seq
-        when "[A" then :up
-        when "[B" then :down
-        else :escape
-        end
-      else
-        byte
-      end
-    rescue IO::WaitReadable, EOFError
-      nil
-    end
-  end
-end

data/lib/fun_ci/ansi.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module FunCi
-  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.white(text)       = "\e[37m#{text}#{RESET}"
-    def self.bg_charcoal(text) = "\e[48;5;236m#{text}#{RESET}"
-
-    def self.strip(text)
-      text.gsub(/\e\[[0-9;]*[A-Za-z]/, "")
-    end
-  end
-end

data/lib/fun_ci/background_wrapper.rb

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

data/lib/fun_ci/board_data.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require "time"
-require_relative "pipeline_run"
-require_relative "stage_job"
-require_relative "streak_counter"
-
-module FunCi
-  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 = PipelineRun.recent(@db, limit: @limit)
-      pipeline_runs.map { |run| enrich_with_stages(run) }
-    end
-
-    def streak
-      pipeline_runs = PipelineRun.recent(@db, limit: @limit)
-      StreakCounter.count(pipeline_runs)
-    end
-
-    def cancel_run(run_id)
-      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 = 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

data/lib/fun_ci/database.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require "sqlite3"
-
-module FunCi
-  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

data/lib/fun_ci/duration_formatter.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module FunCi
-  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)
-      # Show one decimal place, remove trailing zeros
-      sprintf("%.1f", value)
-    end
-    private_class_method :format_decimal
-  end
-end

data/lib/fun_ci/hook_writer.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-require "fileutils"
-
-module FunCi
-  class HookWriter
-    ALLOWED_HOOKS = %w[pre-commit pre-push].freeze
-    MARKER = "# fun-ci-managed-hook"
-
-    HOOK_COMMANDS = {
-      "pre-commit" => "fun-ci trigger --no-validate",
-      "pre-push" => "fun-ci trigger"
-    }.freeze
-
-    HOOK_TEMPLATE = <<~SH
-      #!/bin/sh
-      #{MARKER}
-      COMMIT=$(git rev-parse HEAD 2>/dev/null || echo "0000000000000000000000000000000000000000")
-      BRANCH=$(git branch --show-current 2>/dev/null || echo "unknown")
-      %<command>s "$COMMIT" "$BRANCH"
-    SH
-
-    def self.run(project_root:, hook_type:, stdout: $stdout)
-      new(project_root: project_root, hook_type: hook_type, stdout: stdout).run
-    end
-
-    def initialize(project_root:, hook_type:, stdout:)
-      @project_root = project_root
-      @hook_type = hook_type
-      @stdout = stdout
-    end
-
-    def run
-      return reject("Not a git repository — no .git/ found.") unless git_repo?
-      return reject("Unknown hook type: #{@hook_type}") unless ALLOWED_HOOKS.include?(@hook_type)
-      return skip("Hook #{@hook_type} already exists from another tool — skipping.") if foreign_hook?
-
-      write_hook
-      @stdout.puts "Installed #{@hook_type} hook."
-      0
-    end
-
-    private
-
-    def git_repo?
-      Dir.exist?(File.join(@project_root, ".git"))
-    end
-
-    def hook_path
-      File.join(@project_root, ".git", "hooks", @hook_type)
-    end
-
-    def foreign_hook?
-      File.exist?(hook_path) && !File.read(hook_path).include?(MARKER)
-    end
-
-    def write_hook
-      FileUtils.mkdir_p(File.join(@project_root, ".git", "hooks"))
-      File.write(hook_path, format(HOOK_TEMPLATE, command: HOOK_COMMANDS[@hook_type]))
-      File.chmod(0o755, hook_path)
-    end
-
-    def reject(message)
-      @stdout.puts message
-      1
-    end
-
-    def skip(message)
-      @stdout.puts message
-      0
-    end
-  end
-end

data/lib/fun_ci/installer.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "project_detector"
-require_relative "template_writer"
-require_relative "maven_linter_detector"
-
-module FunCi
-  class Installer
-    def self.run(project_root:, stdout: $stdout, pom_reader: nil)
-      new(project_root: project_root, stdout: stdout, pom_reader: pom_reader).run
-    end
-
-    def initialize(project_root:, stdout:, pom_reader: nil)
-      @project_root = project_root
-      @stdout = stdout
-      @pom_reader = pom_reader || ->(path) { File.read(path) }
-    end
-
-    def run
-      if Dir.exist?(File.join(@project_root, ".fun-ci"))
-        @stdout.puts ".fun-ci/ already exists — skipping init."
-        return 0
-      end
-
-      filenames = Dir.children(@project_root)
-      detected = ProjectDetector.new(filenames).detect
-
-      if detected == :unknown
-        @stdout.puts "Could not detect project type. Create .fun-ci/ manually."
-        return 1
-      end
-
-      @stdout.puts "Detected: #{detected.to_s.tr("_", " ")}"
-
-      lint_override = detect_maven_linter(detected)
-      TemplateWriter.new(detected, @project_root, lint_override: lint_override).write
-
-      @stdout.puts "Created .fun-ci/ with template scripts."
-      0
-    end
-
-    private
-
-    def detect_maven_linter(detected)
-      return nil unless detected == :jvm_maven
-
-      pom_path = File.join(@project_root, "pom.xml")
-      pom_content = @pom_reader.call(pom_path)
-      command = MavenLinterDetector.new(pom_content).lint_command
-      command == MavenLinterDetector::DEFAULT_COMMAND ? nil : command
-    end
-  end
-end

data/lib/fun_ci/maven_linter_detector.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module FunCi
-  class MavenLinterDetector
-    LINTERS = [
-      { artifact_id: "detekt-maven-plugin", command: "mvn detekt:check" },
-      { artifact_id: "ktlint-maven-plugin", command: "mvn ktlint:check" },
-      { artifact_id: "maven-checkstyle-plugin", command: "mvn checkstyle:check" },
-      { artifact_id: "spotbugs-maven-plugin", command: "mvn spotbugs:check" },
-      { artifact_id: "maven-pmd-plugin", command: "mvn pmd:check" }
-    ].freeze
-
-    DEFAULT_COMMAND = "mvn verify -DskipTests"
-
-    def initialize(pom_content)
-      @pom_content = pom_content
-    end
-
-    def lint_command
-      match = LINTERS.find { |linter| @pom_content.include?(linter[:artifact_id]) }
-      match ? match[:command] : DEFAULT_COMMAND
-    end
-  end
-end

data/lib/fun_ci/pipeline_forker.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "database"
-require_relative "pipeline_recorder"
-require_relative "background_wrapper"
-
-module FunCi
-  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 = Database.connection(db_path)
-      recorder = 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 = DbRecorder.for_background(db_path, pipeline_run_id)
-      BackgroundWrapper.new(recorder: recorder, job_id: job_id, executor: executor).run
-      recorder.close
-    end
-  end
-end

data/lib/fun_ci/pipeline_recorder.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "pipeline_run"
-require_relative "stage_job"
-
-module FunCi
-  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