railbow 0.1.0

data/lib/railbow/demo/fixtures.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Railbow
+  module Demo
+    module Fixtures
+      # Fictional veterinary SaaS — "PawClinic"
+      # 4 authors: Alice Chen, Bob Wilson, Carol Davis, Me (current user)
+      DEMO_USER_NAME = "Me"
+      DEMO_USER_EMAIL = "me@example.com"
+
+      AUTHORS = {
+        alice: {name: "Alice Chen", email: "alice@pawclinic.dev"},
+        bob: {name: "Bob Wilson", email: "bob@pawclinic.dev"},
+        carol: {name: "Carol Davis", email: "carol@pawclinic.dev"},
+        me: {name: DEMO_USER_NAME, email: DEMO_USER_EMAIL}
+      }.freeze
+
+      # Each entry: [days_ago, time, name, author, status, tables, branch, landed_days_after]
+      # landed_days_after: if > 0, the landing date badge shows (must be >7 to trigger)
+      MIGRATION_TEMPLATES = [
+        # ── ~68 days ago (pre-last month) ──
+        [68, "09:30:12", "CreateVeterinarians", :alice, "up", ["vets"], nil, 0],
+        [66, "14:15:00", "CreatePets", :bob, "up", ["pets"], nil, 13],
+        [65, "11:00:30", "CreateOwners", :alice, "up", ["owners"], nil, 13],
+        [62, "16:30:00", "AddBreedAndColorToPets", :me, "up", ["pets"], nil, 0],
+        [59, "08:45:00", "CreateAppointments", :carol, "up", ["appointments"], nil, 0],
+        [57, "15:12:00", "AddOwnerIdToPets", :bob, "up", ["pets", "owners"], nil, 12],
+        [55, "10:00:00", "CreateVaccinations", :alice, "up", ["vaccinations"], nil, 0],
+        [53, "17:20:00", "AddPhoneToOwners", :carol, "up", ["owners"], nil, 0],
+        [51, "09:15:00", "CreateTreatments", :me, "up", ["treatments"], nil, 0],
+        [49, "14:00:00", "AddWeightToPets", :bob, "up", ["pets"], nil, 0],
+        # ── ~45 days ago (last month) ──
+        [45, "09:30:00", "CreateBillingRecords", :me, "up", ["bills"], nil, 0],
+        [43, "16:00:00", "AddVetIdToAppointments", :carol, "up", ["appointments", "vets"], nil, 0],
+        [41, "12:00:00", "CreateMedicalRecords", :bob, "up", ["records"], nil, 15],
+        [39, "08:30:00", "AddIndexOnPetsBreed", :alice, "up", ["pets"], nil, 0],
+        [37, "14:00:00", "CreateSpecies", :me, "up", ["species"], nil, 0],
+        [35, "11:00:00", "AddSpeciesIdToPets", :me, "up", ["pets", "species", "breeds"], nil, 0],
+        [33, "09:30:00", "AddNotesToAppointments", :carol, "up", ["appointments"], nil, 0],
+        [31, "15:45:00", "CreateLabResults", :alice, "up", ["labs"], nil, 0],
+        [29, "10:20:00", "AddDosageToTreatments", :bob, "up", ["treatments"], nil, 0],
+        [27, "13:00:00", "CreateReminders", :me, "up", ["reminders", "pets"], nil, 0],
+        # ── ~25 days ago (current month) ──
+        [24, "10:00:00", "CreatePrescriptions", :bob, "up", ["prescriptions"], nil, 10],
+        [22, "14:00:00", "AddWeightHistoryToPets", :alice, "up", ["pets"], nil, 0],
+        [20, "16:30:00", "AddStatusToAppointments", :carol, "up", ["appointments"], nil, 0],
+        [18, "09:00:00", "CreateInventory", :me, "up", ["inventory"], nil, 0],
+        [16, "11:30:00", "AddAllergiesToPets", :alice, "up", ["pets", "allergies"], nil, 0],
+        [14, "08:30:00", "RenameAmountOnBills", :me, "up", ["bills"], nil, 0],
+        [10, "15:00:00", "AddMicrochipToPets", :bob, "up", ["pets"], nil, 0],
+        [5, "16:00:00", "AddInsuranceToOwners", :carol, "up", ["owners", "plans", "bills", "logs"], "VET-150", 0],
+        [3, "11:00:00", "CreateInsuranceClaims", :me, "up", ["claims"], "VET-152", 0],
+        [2, "14:30:00", "AddPolicyNumberToBills", :me, "down", ["bills"], "VET-152", 0]
+      ].freeze
+
+      # Build migrations with dates relative to today.
+      def self.migrations
+        today = Date.today
+        MIGRATION_TEMPLATES.map do |days_ago, time, name, author_key, status, tables, branch, landed_after|
+          date = today - days_ago
+          h, m, s = time.split(":").map(&:to_i)
+          version = date.strftime("%Y%m%d") + format("%02d%02d%02d", h, m, s)
+
+          landed_date = (landed_after > 7) ? date + landed_after : nil
+
+          author = AUTHORS[author_key]
+          {
+            status: status,
+            version: version,
+            name: name,
+            author_name: author[:name],
+            author_email: author[:email],
+            branch: branch,
+            landed_date: landed_date,
+            tables: tables
+          }
+        end
+      end
+
+      ROUTES = [
+        # Pets
+        {verb: "GET", path: "/pets", reqs: "pets#index", name: "pets"},
+        {verb: "GET", path: "/pets/new", reqs: "pets#new", name: "new_pet"},
+        {verb: "POST", path: "/pets", reqs: "pets#create", name: ""},
+        {verb: "GET", path: "/pets/:id", reqs: "pets#show", name: "pet"},
+        {verb: "GET", path: "/pets/:id/edit", reqs: "pets#edit", name: "edit_pet"},
+        {verb: "PATCH|PUT", path: "/pets/:id", reqs: "pets#update", name: ""},
+        {verb: "DELETE", path: "/pets/:id", reqs: "pets#destroy", name: ""},
+        # Owners
+        {verb: "GET", path: "/owners", reqs: "owners#index", name: "owners"},
+        {verb: "POST", path: "/owners", reqs: "owners#create", name: ""},
+        {verb: "GET", path: "/owners/:id", reqs: "owners#show", name: "owner"},
+        # Appointments (nested under pets)
+        {verb: "GET", path: "/pets/:pet_id/appointments", reqs: "appointments#index", name: "pet_appointments"},
+        {verb: "POST", path: "/pets/:pet_id/appointments", reqs: "appointments#create", name: ""},
+        {verb: "GET", path: "/pets/:pet_id/appointments/:id", reqs: "appointments#show", name: "pet_appointment"},
+        # API namespace
+        {verb: "GET", path: "/api/v1/pets", reqs: "api/v1/pets#index", name: "api_v1_pets"},
+        {verb: "GET", path: "/api/v1/pets/:id", reqs: "api/v1/pets#show", name: "api_v1_pet"}
+      ].freeze
+
+      # Simulate `db:migrate` running — list of [name, timing_seconds]
+      MIGRATE_STEPS = [
+        ["CreateInsuranceClaims", [
+          ["create_table(:insurance_claims)", 0.0043],
+          ["add_index(:insurance_claims, :owner_id)", 0.0012]
+        ]],
+        ["AddPolicyNumberToBills", [
+          ["add_column(:bills, :policy_number, :string)", 0.0008]
+        ]],
+        ["AddInsuranceToOwners", [
+          ["add_column(:owners, :insurance_provider, :string)", 0.0006],
+          ["add_column(:owners, :insurance_id, :string)", 0.0005],
+          ["add_index(:owners, :insurance_provider)", 0.2310]
+        ]]
+      ].freeze
+    end
+  end
+end

data/lib/railbow/demo/migrate_demo.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "../formatters/base"
+require_relative "fixtures"
+
+module Railbow
+  module Demo
+    class MigrateDemo
+      def self.run
+        new.run
+      end
+
+      def run
+        f = Railbow::Formatters::Base.new
+
+        Fixtures::MIGRATE_STEPS.each do |name, steps|
+          puts
+          puts f.cyan("#{f.emoji(:migrating)} #{name}: migrating...")
+
+          total_time = 0.0
+          steps.each do |operation, seconds|
+            total_time += seconds
+            timing = f.format_timing(seconds)
+            puts "  #{f.green(f.emoji(:check))} #{operation} \u2192 #{timing}"
+          end
+
+          total_timing = f.format_timing(total_time)
+          puts f.green("#{f.emoji(:migrated)} #{name}: migrated") + " (#{total_timing} total)"
+        end
+
+        puts
+      end
+    end
+  end
+end

data/lib/railbow/demo/routes_demo.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative "../formatters/base"
+require_relative "../table"
+require_relative "../config"
+require_relative "fixtures"
+
+module Railbow
+  module Demo
+    class RoutesDemo
+      VERB_COLORS = {
+        "GET" => Railbow::Formatters::Base::GREEN,
+        "POST" => Railbow::Formatters::Base::YELLOW,
+        "PATCH" => Railbow::Formatters::Base::CYAN,
+        "PUT" => Railbow::Formatters::Base::CYAN,
+        "DELETE" => Railbow::Formatters::Base::RED
+      }.freeze
+
+      RESET = Railbow::Formatters::Base::RESET
+      BOLD = Railbow::Formatters::Base::BOLD
+      DIM = Railbow::Formatters::Base::DIM
+      CYAN = Railbow::Formatters::Base::CYAN
+
+      def self.run
+        new.run
+      end
+
+      def run
+        routes = Fixtures::ROUTES
+        groups = routes.group_by { |r| r[:reqs].include?("#") ? r[:reqs].split("#").first : "(other)" }
+
+        lines = []
+        groups.each do |label, group_routes|
+          lines << ""
+          lines << "#{BOLD}#{CYAN}\u2500\u2500 #{label} \u2500\u2500#{RESET}"
+
+          columns = [
+            Railbow::Table::Column.new(label: "Verb", sticky: true),
+            Railbow::Table::Column.new(label: "URI Pattern", sticky: true),
+            Railbow::Table::Column.new(label: "Controller#Action"),
+            Railbow::Table::Column.new(label: "Prefix")
+          ]
+
+          rows = group_routes.map { |r|
+            [
+              colorize_verb(r[:verb]),
+              colorize_path(r[:path]),
+              colorize_reqs(r[:reqs]),
+              r[:name].empty? ? "" : "#{DIM}#{r[:name]}#{RESET}"
+            ]
+          }
+
+          renderer = Railbow::Table::Renderer.new(
+            columns: columns,
+            theme: Railbow::Table::Themes::PLAIN,
+            compact: {oneline: false, dense: false, noheader: false, maxw: nil, hidden_columns: []},
+            aliases: Railbow::Config.table_aliases
+          )
+          lines << renderer.render(rows)
+        end
+
+        puts lines.join("\n")
+      end
+
+      private
+
+      def colorize_verb(verb)
+        return verb if verb.empty?
+
+        verb.split("|").map { |v|
+          color = VERB_COLORS[v]
+          color ? "#{color}#{v}#{RESET}" : v
+        }.join("#{DIM}|#{RESET}")
+      end
+
+      def colorize_path(path)
+        return path if path.empty?
+
+        path.gsub(/:[a-z_]+|\*[a-z_]+/) { |match| "#{CYAN}#{match}#{RESET}" }
+      end
+
+      def colorize_reqs(reqs)
+        return reqs if reqs.empty?
+
+        if reqs.include?("#")
+          controller, action = reqs.split("#", 2)
+          "#{BOLD}#{controller}#{RESET}#{DIM}##{RESET}#{action}"
+        else
+          "#{DIM}#{reqs}#{RESET}"
+        end
+      end
+    end
+  end
+end

data/lib/railbow/demo/runner.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "../../railbow"
+require_relative "../logo"
+
+module Railbow
+  module Demo
+    class Runner
+      SUBCOMMANDS = %w[status migrate routes all].freeze
+
+      def self.run(subcommand = "status")
+        subcommand = subcommand.to_s.downcase
+        unless SUBCOMMANDS.include?(subcommand)
+          warn "Unknown demo: #{subcommand}"
+          warn "Available: #{SUBCOMMANDS.join(", ")}"
+          exit 1
+        end
+
+        Railbow.print_logo
+        puts
+
+        if subcommand == "all"
+          run_all
+        else
+          run_one(subcommand)
+        end
+      end
+
+      def self.run_one(subcommand)
+        case subcommand
+        when "status"
+          require_relative "status_demo"
+          StatusDemo.run
+        when "migrate"
+          require_relative "migrate_demo"
+          MigrateDemo.run
+        when "routes"
+          require_relative "routes_demo"
+          RoutesDemo.run
+        end
+      end
+
+      def self.run_all
+        %w[status migrate routes].each do |sub|
+          puts "\n\e[1m\e[36m── railbow demo #{sub} ──\e[0m\n"
+          run_one(sub)
+        end
+      end
+    end
+  end
+end

data/lib/railbow/demo/status_demo.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "date"
+require_relative "../formatters/base"
+require_relative "../table"
+require_relative "../config"
+require_relative "fixtures"
+
+module Railbow
+  module Demo
+    class StatusDemo
+      def self.run
+        new.run
+      end
+
+      def run
+        formatter = Railbow::Formatters::Base.new
+        migrations = Fixtures.migrations
+
+        puts "\n#{formatter.emoji(:status)} Database: #{formatter.cyan("db/development.sqlite3")}"
+        puts
+
+        # Use default config: author:me, diff, calendar, tables, wticks, full date
+        date_format = "full"
+        tables_enabled = true
+        diff_enabled = true
+
+        git_email = Fixtures::DEMO_USER_EMAIL
+        git_name = Fixtures::DEMO_USER_NAME
+
+        # Latest migration date — for "fresh" landed badge detection
+        latest_version = migrations.last[:version]
+        latest_mig_date = parse_version_date(latest_version)
+
+        # Check if any landed tags exist
+        has_landed_tags = migrations.any? { |m|
+          next false unless m[:landed_date]
+          mig_date = parse_version_date(m[:version])
+          mig_date && (m[:landed_date] - mig_date) > 7
+        }
+
+        needs_name_truncation = tables_enabled || diff_enabled || has_landed_tags
+        name_col_width = needs_name_truncation ? 60 : nil
+
+        table_columns = [
+          Railbow::Table::Column.new(label: "Status", max_width: 6, sticky: true),
+          Railbow::Table::Column.new(label: "Migration ID", sticky: true),
+          Railbow::Table::Column.new(label: "Created At"),
+          Railbow::Table::Column.new(label: "Migration Name",
+            max_width: name_col_width,
+            truncate: needs_name_truncation)
+        ]
+        # No Author column in default config (author:me only highlights)
+
+        tables_truncate_fn = ->(cell_raw, max_w) { formatter.table_tags_fitted(cell_raw, max_w) }
+        table_columns << Railbow::Table::Column.new(label: "Tables", truncate: true, truncate_fn: tables_truncate_fn)
+
+        # Build rows
+        highlight_rows = Set.new
+        rows = migrations.each_with_index.map do |m, idx|
+          colored_status = case m[:status]
+          when "up" then formatter.green_bold("up")
+          when "down" then formatter.yellow_bold("down")
+          else m[:status]
+          end
+
+          display_name = m[:name]
+
+          # Diff tag (branch badge)
+          diff_tag = m[:branch] ? formatter.diff_tag_branch(m[:branch]) : nil
+
+          # Landed badge
+          landed_tag = nil
+          if m[:landed_date]
+            mig_date = parse_version_date(m[:version])
+            if mig_date && (m[:landed_date] - mig_date) > 7
+              fresh = latest_mig_date && m[:landed_date] >= latest_mig_date
+              landed_tag = formatter.landed_tag(m[:landed_date], fresh: fresh)
+            end
+          end
+
+          # Append tags to display_name
+          tags = [landed_tag, diff_tag].compact.join(" ")
+          if !tags.empty? && name_col_width
+            tags_width = formatter.display_width(formatter.strip_ansi(tags))
+            available = name_col_width - tags_width - 2
+            display_name = formatter.truncate_str(display_name, available)
+            name_width = formatter.display_width(formatter.strip_ansi(display_name))
+            padding = name_col_width - name_width - tags_width
+            display_name = "#{display_name}#{" " * [padding, 2].max}#{tags}"
+          elsif !tags.empty?
+            display_name = "#{display_name}  #{tags}"
+          end
+
+          created_at = formatter.format_date(m[:version], date_format)
+
+          # Highlight current user's rows (author:me mode)
+          if m[:author_email] == git_email ||
+              (git_name && m[:author_name] && m[:author_name].downcase == git_name.downcase)
+            highlight_rows << idx
+          end
+
+          # Table tags
+          table_tags = formatter.table_tags(m[:tables])
+
+          [colored_status, m[:version], created_at, display_name, table_tags]
+        end
+
+        # Calendar separators
+        separators = {}
+        versions = migrations.map { |m| m[:version] }
+        month_keys = versions.map { |v| v[0..5] }
+        calendar_label_fmt = "%b %Y   W%V"
+
+        if month_keys.uniq.size > 1
+          month_keys.each_with_index do |mk, i|
+            next if i == 0
+            if mk != month_keys[i - 1]
+              v = versions[i]
+              date = Date.new(v[0..3].to_i, v[4..5].to_i, v[6..7].to_i)
+              separators[i] = date.strftime(calendar_label_fmt)
+            end
+          end
+        end
+
+        # Week ticks
+        tick_rows = Set.new
+        prev_week = nil
+        versions.each_with_index do |v, i|
+          y = v[0..3].to_i
+          m = v[4..5].to_i
+          d = v[6..7].to_i
+          next if y == 0 || m == 0 || d == 0
+
+          week = Date.new(y, m, d).cweek
+
+          if i > 0 && prev_week && week != prev_week
+            tick_rows << i
+          end
+
+          prev_week = week
+        end
+
+        aliases = Railbow::Config.table_aliases
+        renderer = Railbow::Table::Renderer.new(
+          columns: table_columns,
+          theme: Railbow::Table::Themes::WALLS,
+          compact: {oneline: false, dense: false, noheader: false, maxw: nil, hidden_columns: []},
+          aliases: aliases
+        )
+        puts renderer.render(rows, separators: separators, highlight_rows: highlight_rows, tick_rows: tick_rows, tick_col: 2)
+      end
+
+      private
+
+      def parse_version_date(version)
+        v = version.to_s
+        Date.new(v[0..3].to_i, v[4..5].to_i, v[6..7].to_i)
+      rescue Date::Error
+        nil
+      end
+    end
+  end
+end

data/lib/railbow/formatters/base.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require "zlib"
+require_relative "../text_utils"
+
+module Railbow
+  module Formatters
+    class Base
+      include TextUtils
+
+      RESET = "\e[0m"
+      BOLD = "\e[1m"
+      GREEN = "\e[32m"
+      YELLOW = "\e[33m"
+      RED = "\e[31m"
+      CYAN = "\e[36m"
+      DIM = "\e[2m"
+      WHITE = "\e[97m"
+
+      TABLE_PALETTE = [
+        196, # red
+        208, # orange
+        220, # yellow
+        76,  # green
+        48,  # mint
+        39,  # cyan
+        33,  # blue
+        63,  # indigo
+        129, # purple
+        170, # pink
+        214, # amber
+        109  # teal
+      ].freeze
+
+      BRIGHT_WHITE = "\e[1;97m"
+
+      def dim(str) = "#{DIM}#{str}#{RESET}"
+      def green(str) = "#{GREEN}#{str}#{RESET}"
+      def yellow(str) = "#{YELLOW}#{str}#{RESET}"
+      def red(str) = "#{RED}#{str}#{RESET}"
+      def cyan(str) = "#{CYAN}#{str}#{RESET}"
+      def bold(str) = "#{BOLD}#{str}#{RESET}"
+      def green_bold(str) = "#{GREEN}#{BOLD}#{str}#{RESET}"
+      def yellow_bold(str) = "#{YELLOW}#{BOLD}#{str}#{RESET}"
+
+      def table_color(table_name)
+        TABLE_PALETTE[Zlib.crc32(table_name.to_s) % TABLE_PALETTE.size]
+      end
+
+      def diff_tag_branch(name) = "\e[38;5;39m\u2387 #{name}#{RESET}"
+      def diff_tag_merging(name) = "\e[38;5;213m\u2B07 #{name}#{RESET}"
+
+      def landed_tag(date, fresh: false)
+        color = fresh ? "\e[38;5;220m" : DIM
+        "#{color}↪ #{date.strftime("%b %d")}#{RESET}"
+      end
+
+      def table_tag(table_name)
+        color_code = table_color(table_name)
+        "\e[38;5;#{color_code}m● #{table_name}#{RESET}"
+      end
+
+      def table_tags(table_names)
+        return "" if table_names.nil? || table_names.empty?
+
+        table_names.map { |t| table_tag(t) }.join(" ")
+      end
+
+      # Re-fits a pre-formatted table_tags string within max_width,
+      # showing full table names and "+N" for overflow.
+      # Accepts the full formatted string (with ANSI) and splits it into segments.
+      def table_tags_fitted(formatted_str, max_width)
+        return formatted_str if formatted_str.nil? || formatted_str.empty?
+
+        # Split into individual tag segments: each is "\e[38;5;NNNm● name\e[0m"
+        segments = formatted_str.scan(/\e\[38;5;\d+m● [^\e]+\e\[0m/)
+        return formatted_str if segments.empty?
+
+        total = segments.size
+        plain_segments = segments.map { |s| strip_ansi(s) }
+
+        # Try fitting all tags
+        return formatted_str if display_width(plain_segments.join(" ")) <= max_width
+
+        # Try fitting progressively fewer tags with +N suffix
+        (total - 1).downto(1) do |count|
+          remaining = total - count
+          suffix = " +#{remaining}"
+          candidate = plain_segments[0...count].join(" ") + suffix
+          if display_width(candidate) <= max_width
+            return segments[0...count].join(" ") + suffix
+          end
+        end
+
+        # Try fitting a truncated first table name + overflow.
+        # Need at least 7 chars: "● t… +N" (dot + color prefix use no visible width beyond the dot)
+        if max_width >= 7
+          suffix = (total > 1) ? " +#{total - 1}" : ""
+          # Available width for "● name…" part
+          avail = max_width - display_width(suffix)
+          # "● " prefix = 2 chars visible, plus at least 1 char of name + ellipsis (1 char)
+          if avail >= 4 # "● " (2) + at least 1 char + "…" (1)
+            first_plain = plain_segments[0] # e.g. "● some_table"
+            name_part = first_plain.sub(/^● /, "")
+            # Truncate name to fit: avail - 2 ("● ") - 1 ("…") = chars for name
+            name_max = avail - 2 - 1
+            truncated_name = name_part[0, name_max]
+            color_match = segments[0].match(/\e\[38;5;\d+m/)
+            color = color_match ? color_match[0] : ""
+            return "#{color}● #{truncated_name}…#{RESET}#{suffix}"
+          end
+        end
+
+        # Absolute fallback: just +N
+        "+#{total}"
+      end
+
+      def format_timing(seconds)
+        milliseconds = (seconds * 1000).round(1)
+
+        timing_str = if milliseconds < 1
+          "#{(milliseconds * 1000).round(0)}μs"
+        else
+          "#{milliseconds}ms"
+        end
+
+        cyan(timing_str)
+      end
+
+      def emoji(type)
+        case type
+        when :migrating then "🚀"
+        when :migrated then "✅"
+        when :reverting then "⏪"
+        when :reverted then "✅"
+        when :check then "✓"
+        when :status then "📊"
+        else ""
+        end
+      end
+
+      def format_date(timestamp, mode = "full")
+        ts = timestamp.to_s
+        return ts if ts.length != 14
+
+        time = begin
+          Time.new(
+            ts[0..3].to_i, ts[4..5].to_i, ts[6..7].to_i,
+            ts[8..9].to_i, ts[10..11].to_i, ts[12..13].to_i
+          )
+        rescue ArgumentError
+          return ts
+        end
+
+        case mode
+        when "full"
+          time.strftime("%Y-%m-%d %H:%M:%S")
+        when "rel"
+          format_relative_time_from(time)
+        when "short"
+          time.strftime("%b %-d")
+        when /\Acustom\((.+)\)\z/
+          time.strftime($1)
+        else
+          time.strftime("%Y-%m-%d %H:%M:%S")
+        end
+      end
+
+      private
+
+      def format_relative_time_from(time)
+        diff = Time.now - time
+        return "just now" if diff < 0
+
+        minutes = diff.to_i / 60
+        hours = minutes / 60
+        days = hours / 24
+        weeks = days / 7
+        months = days / 30
+        years = days / 365
+
+        if minutes < 1 then "just now"
+        elsif hours < 1 then "~#{minutes}min ago"
+        elsif days < 1 then "~#{hours}hr ago"
+        elsif weeks < 1 then "~#{days}d ago"
+        elsif months < 1 then "~#{weeks}w ago"
+        elsif years < 1 then "~#{months}mo ago"
+        else "~#{years}y ago"
+        end
+      end
+
+      public
+    end
+  end
+end

data/lib/railbow/git_utils.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Railbow
+  # Runs git commands defensively: when the git binary is not installed,
+  # returns empty output and a failed status instead of raising Errno::ENOENT.
+  module GitUtils
+    MISSING_GIT_STATUS = Object.new
+
+    def MISSING_GIT_STATUS.success?
+      false
+    end
+
+    module_function
+
+    def capture2(*args)
+      Open3.capture2("git", *args)
+    rescue Errno::ENOENT
+      ["", MISSING_GIT_STATUS]
+    end
+
+    def capture3(*args)
+      Open3.capture3("git", *args)
+    rescue Errno::ENOENT
+      ["", "", MISSING_GIT_STATUS]
+    end
+  end
+end