fun_ci 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bacc0733c3648d5b5422304a7c319be52f1531e98f1c802e4a3d2a5280928ba9
+  data.tar.gz: '097d7eaea4e663259c0b745724e6a4d281af1aa60b0ebb3bd78a14c8add5bb57'
+SHA512:
+  metadata.gz: feb14f7ff5ba1b67c66b3aa9cddeb9a160320aab302abf9aa60f3cb58b88395e0493abd50dd44db2ddd4030680d0a3c77e99f50cd7408309fe7e3cec9f692163
+  data.tar.gz: 8c3cf91d027932fbb998bb3f341cfced2752de43d926a10310f1900ce672de041f75b830379c665b3286daf93bb0c0b0364af47ba1dd116af8c1cc393481ea85

data/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+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.0.0] - 2026-02-21
+
+### Added
+- Four-stage local CI pipeline (lint, build, fast, slow) with strict time budgets (30s/30s/10s/5min)
+- Unified CLI (`fun-ci`) with subcommands: trigger, console, init, install-hooks, check
+- Pre-commit hook (background fork, non-blocking) and pre-push hook (synchronous, blocking)
+- TUI dashboard with vim-style navigation (j/k/c/q), pagination, and project path display
+- Project scaffolding with built-in templates for Ruby (Bundler), JVM (Gradle Kotlin/Groovy, Maven)
+- SQLite persistence with WAL mode for pipeline results
+- Parallel lint + build stages with background slow suite
+- Smart Maven linter detection for template generation
+- Stale pipeline auto-cancellation

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Erik T. Madsen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,107 @@
+# Fun-CI
+
+Opinionated local CI that checks your code before it leaves your machine. Runs a four-stage pipeline on every commit with strict time budgets, so your feedback loop stays fast.
+
+## How It Works
+
+Fun-CI hooks into git and runs your pipeline locally:
+
+1. **Lint + Build** (parallel, 30s budget each) -- static analysis and compilation
+2. **Slow suite** (spawned in background, 5min budget) -- integration/end-to-end tests
+3. **Fast suite** (synchronous, 10s budget) -- unit tests
+
+On **pre-commit**, the entire pipeline forks to the background so your commit is not blocked. On **pre-push**, lint, build, and fast suite must pass before the push proceeds. The slow suite always runs in the background.
+
+Results are stored in a local SQLite database. A terminal dashboard lets you monitor pipeline status across branches.
+
+## Getting Started
+
+```bash
+gem install fun_ci
+cd your-project
+fun-ci init --everything
+```
+
+This does three things:
+1. Detects your project type and creates `.fun-ci/` with template scripts
+2. Installs pre-commit and pre-push git hooks
+3. Verifies the setup is valid
+
+`fun-ci init` has built-in templates for Ruby (Bundler), JVM (Gradle Kotlin, Gradle Groovy, Maven), but Fun-CI works with any project -- just write your own shell scripts.
+
+### Manual Setup
+
+If you prefer to set things up step by step:
+
+```bash
+fun-ci init              # Create .fun-ci/ with template scripts
+fun-ci install-hooks     # Install git hooks
+fun-ci check             # Verify everything is configured
+```
+
+Then edit the generated scripts in `.fun-ci/` to match your project:
+- `lint.sh` -- linter/static analysis
+- `build.sh` -- build/compile step
+- `fast.sh` -- fast test suite (unit tests)
+- `slow.sh` -- slow test suite (integration tests)
+
+Each script receives the commit hash as its first argument.
+
+## Commands
+
+```
+fun-ci trigger <commit> <branch>               Run the full pipeline
+fun-ci trigger --no-validate <commit> <branch>  Fork pipeline to background (used by pre-commit)
+fun-ci console                                 Launch the TUI dashboard
+fun-ci init                                     Scaffold .fun-ci/ for detected project type
+fun-ci init --everything                        init + install-hooks + check in one step
+fun-ci install-hooks                            Install pre-commit and pre-push hooks
+fun-ci install-hooks pre-commit                 Install a single hook type
+fun-ci check                                    Verify .fun-ci/ setup
+```
+
+## Git Hooks
+
+After `fun-ci install-hooks`, two hooks are active:
+
+**pre-commit** -- Runs `fun-ci trigger --no-validate <commit> <branch>`. This forks the pipeline into a background process and returns immediately, so commits are never blocked.
+
+**pre-push** -- Runs `fun-ci trigger <commit> <branch>`. This validates the project config, runs lint + build + fast suite synchronously, and blocks the push if any stage fails. The slow suite runs in the background.
+
+## Admin Dashboard
+
+```bash
+fun-ci console
+```
+
+Opens a terminal UI showing pipeline status across all branches. Navigation:
+
+- `j` / `k` -- scroll up/down
+- `c` -- cancel a running pipeline
+- `q` -- quit
+
+## Time Budgets
+
+| Stage | Budget | Blocks |
+|-------|--------|--------|
+| Lint  | 30s    | push   |
+| Build | 30s    | push   |
+| Fast  | 10s    | push   |
+| Slow  | 5min   | nothing (background) |
+
+If a stage exceeds its budget, it is killed and reported as timed out.
+
+## Development
+
+```bash
+bundle install
+rake test
+```
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for release history.
+
+## License
+
+MIT

data/exe/fun-ci

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/fun_ci"
+require_relative "../lib/fun_ci/cli"
+
+exit FunCi::Cli.run(ARGV)

data/exe/fun-ci-trigger

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/fun_ci"
+require_relative "../lib/fun_ci/trigger"
+require_relative "../lib/fun_ci/pipeline_recorder"
+
+require "tmpdir"
+
+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)
+
+recorder = FunCi::DbRecorder.new(db)
+
+exit FunCi::Trigger.run_from_args(ARGV, recorder: recorder)

data/exe/fun-ci-tui

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/fun_ci"
+require_relative "../lib/fun_ci/admin_tui"
+
+require "tmpdir"
+require "io/console"
+
+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)
+
+tui = FunCi::AdminTui.new(db: db, width_provider: -> { IO.console&.winsize&.dig(1) || 80 })
+tui.run

data/lib/fun_ci/admin_tui.rb

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

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

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

@@ -0,0 +1,51 @@
+# 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/cli.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+require_relative "../fun_ci"
+
+module FunCi
+  class Cli
+    ROUTES = {
+      "trigger" => :run_trigger,
+      "console" => :run_console,
+      "init" => :run_init,
+      "install-hooks" => :run_install_hooks,
+      "check" => :run_check
+    }.freeze
+
+    def self.run(args, stdout: $stdout, stderr: $stderr, handlers: {})
+      new(stdout: stdout, stderr: stderr, handlers: handlers).run(args)
+    end
+
+    def initialize(stdout:, stderr:, handlers:)
+      @stdout = stdout
+      @stderr = stderr
+      @handlers = handlers
+    end
+
+    def run(args)
+      subcommand = args.first
+      return help(0) if %w[-h --help].include?(subcommand)
+      return version if subcommand == "--version"
+      unless ROUTES.key?(subcommand)
+        print_error(subcommand)
+        return 1
+      end
+      dispatch(subcommand, args.drop(1))
+    end
+
+    private
+
+    def dispatch(subcommand, args)
+      return @handlers[subcommand].call(args) if @handlers.key?(subcommand)
+      send(ROUTES[subcommand], args)
+    end
+
+    def run_trigger(args)
+      require_relative "trigger"
+      require_relative "pipeline_recorder"
+      db = setup_db
+      recorder = DbRecorder.new(db)
+      Trigger.run_from_args(args, stdout: @stdout, stderr: @stderr, recorder: recorder)
+    end
+
+    def run_console(_args)
+      require_relative "admin_tui"
+      require "io/console"
+      db = setup_db
+      tui = AdminTui.new(db: db, width_provider: -> { IO.console&.winsize&.dig(1) || 80 })
+      tui.run
+      0
+    end
+
+    def run_init(args)
+      require_relative "installer"
+      code = 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
+      run_check([])
+    end
+
+    def run_install_hooks(args)
+      require_relative "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)
+        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)
+    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
+    end
+
+    HELP_TEXT = <<~HELP
+      fun-ci - Opinionated, local-first CI for your projects
+
+      Usage:
+        fun-ci <command> [options]
+
+      Commands:
+        trigger        Run CI pipeline for a commit
+        console        Launch the admin TUI dashboard
+        init           Initialize .fun-ci/ with template scripts
+        install-hooks  Install pre-commit and pre-push git hooks
+        check          Verify project setup
+
+      Options:
+        -h, --help     Show this help message
+        --version      Show version
+
+      Trigger options:
+        --no-validate  Fork pipeline to background and return immediately
+
+      Init options:
+        --everything   Run init + install-hooks + check in one step
+
+      Examples:
+        fun-ci init --everything
+        fun-ci trigger abc1234 main
+        fun-ci trigger --no-validate abc1234 main
+        fun-ci console
+    HELP
+
+    def help(exit_code)
+      @stdout.puts HELP_TEXT
+      exit_code
+    end
+
+    def version
+      @stdout.puts "fun-ci #{FunCi::VERSION}"
+      0
+    end
+
+    def print_error(subcommand)
+      if subcommand
+        @stderr.puts "fun-ci: unknown command '#{subcommand}'"
+        @stderr.puts ""
+      end
+      @stderr.puts "Usage: fun-ci <command> [options]"
+      @stderr.puts ""
+      @stderr.puts "Run 'fun-ci --help' for available commands."
+    end
+  end
+end