fun_ci 1.0.0

data/lib/fun_ci/database.rb

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

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

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

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

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

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

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

data/lib/fun_ci/pipeline_run.rb

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

data/lib/fun_ci/progress_reporter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module FunCi
+  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

data/lib/fun_ci/project_config.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module FunCi
+  class ProjectConfig
+    REQUIRED_SCRIPTS = %w[lint.sh build.sh fast.sh slow.sh].freeze
+
+    def initialize(project_root)
+      @project_root = project_root
+      @fun_ci_dir = File.join(project_root, ".fun-ci")
+    end
+
+    def folder_exists?
+      Dir.exist?(@fun_ci_dir)
+    end
+
+    def validate
+      errors = []
+
+      unless folder_exists?
+        errors << "No .fun-ci/ folder found in #{@project_root}"
+        return errors
+      end
+
+      REQUIRED_SCRIPTS.each do |script|
+        path = File.join(@fun_ci_dir, script)
+        if !File.exist?(path)
+          errors << ".fun-ci/#{script} is not found"
+        elsif !File.executable?(path)
+          errors << ".fun-ci/#{script} is not executable"
+        end
+      end
+
+      errors
+    end
+
+    def script_path(stage)
+      File.join(@fun_ci_dir, "#{stage}.sh")
+    end
+  end
+end

data/lib/fun_ci/project_detector.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module FunCi
+  class ProjectDetector
+    def initialize(filenames)
+      @filenames = filenames
+    end
+
+    def detect
+      return :ruby_bundler if @filenames.include?("Gemfile")
+      return :jvm_gradle_kotlin if @filenames.include?("build.gradle.kts")
+      return :jvm_gradle_groovy if @filenames.include?("build.gradle")
+      return :jvm_maven if @filenames.include?("pom.xml")
+
+      :unknown
+    end
+  end
+end

data/lib/fun_ci/relative_time.rb

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

data/lib/fun_ci/row_formatter.rb

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

data/lib/fun_ci/screen.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "ansi"
+
+module FunCi
+  class Screen
+    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 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
+          # Replace leading spaces with cursor marker
+          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
+  end
+end