fun_ci 2.0.1 → 2.1.0

data/lib/fun_ci/trunk/fetch.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require_relative "../pipeline/process_runner"
+require_relative "resolver"
+
+module FunCi
+  module Trunk
+    # How a fetch of the trunk went: nil error when it fetched.
+    Fetched = Data.define(:error)
+
+    # Fetches the trunk into a ref of fun-ci's own (architecture.md, Checking against the trunk,
+    # Keeping the trunk fresh). An empty refmap keeps git from moving the
+    # developer's remote-tracking ref too, and nothing may ask them anything:
+    # ssh runs in batch mode unless they have an ssh command of their own.
+    # Started in one thread, so its pid can be recorded, and finished in
+    # another, killed with its process group at the deadline.
+    class Fetch
+      QUIET = { "GIT_TERMINAL_PROMPT" => "0", "SSH_ASKPASS_REQUIRE" => "never", "GCM_INTERACTIVE" => "never" }.freeze
+      NO_PROMPT_SSH = 'if [ -z "$GIT_SSH_COMMAND" ] && ! git config --get core.sshCommand >/dev/null; then ' \
+                      'export GIT_SSH_COMMAND="ssh -o BatchMode=yes -o ConnectTimeout=10"; fi; '
+      OPTIONS = %w[--quiet --no-tags --no-write-fetch-head --no-recurse-submodules --no-auto-maintenance
+                   --refmap=].freeze
+
+      def self.ref_for(ref) = "refs/fun-ci/trunk/#{ref.remote}/#{ref.branch}"
+
+      # Why a fetch failed, from what git printed: its fatal line, else its first, else that it failed.
+      def self.reason(output)
+        lines = output.lines.map(&:strip).reject(&:empty?)
+        (lines.find { |line| line.start_with?("fatal:") } || lines.first || "git fetch failed").to_s
+      end
+
+      # env: what the fetch finds in its environment besides fun-ci's own.
+      def initialize(dir, env:)
+        @launch = Pipeline::ProcessRunner::Launch.new(chdir: dir, env: QUIET.merge(env))
+        @runner = Object.new.extend(Pipeline::ProcessRunner)
+      end
+
+      # Yields the fetch's pid before it runs.
+      def start(ref, &) = @runner.start_process(command(ref), @launch, &)
+
+      def finish(started, deadline:, timer: Pipeline::ProcessRunner::BUDGET)
+        output, status, over = @runner.await_process(started, deadline, launch: @launch, timer: timer)
+        return Fetched.new(error: "no answer within #{deadline} s") if over
+
+        Fetched.new(error: status.success? ? nil : self.class.reason(output))
+      end
+
+      private
+
+      def command(ref)
+        refspec = "+refs/heads/#{ref.branch}:#{self.class.ref_for(ref)}"
+        fetch = Shellwords.join(["git", "fetch", *OPTIONS, ref.remote, refspec])
+        "sh -c #{Shellwords.escape("#{NO_PROMPT_SSH}exec #{fetch}")}"
+      end
+    end
+  end
+end

data/lib/fun_ci/trunk/first_fetch.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "../setup/project_config"
+require_relative "../persistence/trunk_fetches"
+require_relative "description"
+require_relative "git"
+require_relative "resolver"
+
+module FunCi
+  module Trunk
+    # What to say before a project's first fetch of its trunk, where the
+    # developer sees it (architecture.md, Checking against the trunk):
+    # the post-commit hook's run is in the background, and what it prints is not.
+    module FirstFetch
+      # Nil unless the project fetches a remote trunk and never has yet; git lists
+      # the project's refs.
+      def self.notice(project, db, git: Git.new(project))
+        config = Setup::ProjectConfig.new(project)
+        interval = config.trunk_fetch
+        return nil if interval.nil? || config.trunk == "none" || Persistence::TrunkFetches.new(db, project).last
+
+        ref = Resolver.pick(config.trunk, git.refs)
+        ref&.remote ? Description.first_fetch(ref, interval) : nil
+      end
+    end
+  end
+end

data/lib/fun_ci/trunk/git.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "open3"
+require "shellwords"
+require_relative "../pipeline/process_runner"
+require "tmpdir"
+require_relative "../pipeline/git_environment"
+require_relative "merge_check"
+require_relative "resolver"
+
+module FunCi
+  module Trunk
+    # The git the trunk check asks, in the project's repository. A merge
+    # writes its tree and conflicted blobs into a scratch object directory
+    # that borrows the repository's objects, so the repository keeps nothing.
+    class Git
+      REF_PREFIXES = %w[refs/heads/ refs/remotes/].freeze
+
+      # timer: whether a merge finished within its budget (ProcessRunner's timer), for tests to decide.
+      def initialize(dir, timer: Pipeline::ProcessRunner::BUDGET)
+        @dir = dir
+        @timer = timer
+      end
+
+      def counts(commit, trunk) = run("rev-list", "--left-right", "--count", "#{commit}...#{trunk}")
+
+      def merge_tree(commit, trunk) = scratch { |env| merged(commit, trunk, env) }
+
+      # The merge's messages and each conflicted file as the merge leaves it.
+      def explain(commit, trunk)
+        scratch do |env|
+          output = MergeOutput.parse(merged(commit, trunk, env).out)
+          files = output.paths.to_h { |path| [path, run("cat-file", "-p", "#{output.tree}:#{path}", env: env).out] }
+          Explained.new(messages: output.messages, files: files)
+        end
+      end
+
+      # The repository's top directory, or nil outside one.
+      def toplevel
+        answer = run("rev-parse", "--show-toplevel")
+        answer.status.zero? ? answer.out.strip : nil
+      end
+
+      def version = run("--version").out[/\d+(?:\.\d+)+/]
+
+      def refs
+        remotes = run("remote").out.split
+        Refs.new(remotes: remotes, branches: branches, heads: remotes.to_h { |remote| [remote, head(remote)] }.compact)
+      end
+
+      # The commit a ref names, or nil when there is no such ref.
+      def rev(ref)
+        answer = run("rev-parse", "--verify", "--quiet", "#{ref}^{commit}")
+        answer.status.zero? ? answer.out.strip : nil
+      end
+
+      # When the ref last moved, from its reflog, or else when its commit was made.
+      def moved_at(ref)
+        moved = run("reflog", "-1", "--date=unix", "--format=%gd", ref).out[/@\{(\d+)\}/, 1]
+        Time.at(Integer(moved || run("log", "-1", "--format=%ct", ref).out.strip))
+      end
+
+      private
+
+      def branches
+        names = run("for-each-ref", "--format=%(refname)", *REF_PREFIXES).out.split("\n")
+        names.reject { |name| name.end_with?("/HEAD") }.map { |name| strip_prefix(name) }
+      end
+
+      def strip_prefix(name) = REF_PREFIXES.reduce(name) { |short, prefix| short.delete_prefix(prefix) }
+
+      def head(remote)
+        answer = run("symbolic-ref", "--quiet", "refs/remotes/#{remote}/HEAD")
+        answer.status.zero? ? answer.out.strip.delete_prefix("refs/remotes/#{remote}/") : nil
+      end
+
+      # Within the check's budget, killed with its process group past it; what it
+      # prints to stderr comes with what it prints, which is all git says when it fails.
+      def merged(commit, trunk, env)
+        command = Shellwords.join(["git", "merge-tree", "--write-tree", "--name-only", "--messages", commit, trunk])
+        launch = Pipeline::ProcessRunner::Launch.new(chdir: @dir, env: env)
+        output, status, over = Object.new.extend(Pipeline::ProcessRunner)
+                                     .run_process_with_timeout(command, CHECK_BUDGET, launch: launch, timer: @timer)
+        over ? MergeCheck::OVER_BUDGET : MergeCheck::Answer.new(status: status.exitstatus, out: output, err: output)
+      end
+
+      # Yields an environment whose new objects go to a scratch directory that is gone afterwards.
+      def scratch
+        Dir.mktmpdir("fun-ci-merge") do |dir|
+          yield({ "GIT_OBJECT_DIRECTORY" => dir, "GIT_ALTERNATE_OBJECT_DIRECTORIES" => objects })
+        end
+      end
+
+      def objects = File.expand_path(File.join(run("rev-parse", "--git-common-dir").out.strip, "objects"), @dir)
+
+      def run(*, env: {})
+        out, err, status = Open3.capture3(Pipeline::GitEnvironment::CLEAN.merge(env), "git", *, chdir: @dir)
+        MergeCheck::Answer.new(status: status.exitstatus, out: out, err: err)
+      end
+    end
+  end
+end

data/lib/fun_ci/trunk/local.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "../setup/project_config"
+require_relative "checker"
+require_relative "git"
+require_relative "tip_reader"
+
+module FunCi
+  module Trunk
+    # The trunk as the project's git has it now, for the agent commands
+    # (architecture.md, Checking against the trunk): where
+    # its ref points, read the way a check reads it, and a check against it
+    # that never fetches, since a command an agent runs must not wait on the network.
+    class Local
+      # Lets no fetch go, and knows the last one.
+      NoFetch = Data.define(:fetches)
+
+      # Reopened rather than given as a block to Data.define, so tools that
+      # read the source (mutineer) see these as NoFetch's methods.
+      class NoFetch
+        def claim(**) = nil
+        def last = fetches.last
+      end
+
+      # dir: the project's directory, or one inside it.
+      def initialize(dir)
+        @dir = dir
+      end
+
+      # The SHA the tip's trunk points at now, or nil when it is gone.
+      def now_at(tip)
+        ref = Ref.new(remote: tip.remote, branch: tip.branch)
+        TipReader.new(git, -> { Time.now }).tip(ref, fetching: !config.trunk_fetch.nil?)&.sha
+      end
+
+      # fetches: the project's (Persistence::TrunkFetches), for when the last fetch was.
+      def check(sha, fetches)
+        checker = Checker.for(root)
+        pending = checker.start(sha, NoFetch.new(fetches: fetches))
+        pending && checker.finish(pending).check
+      end
+
+      # The conflict between the commit and the tip it was checked against, merged
+      # again; nil when either is gone from the repository (a force push, then gc).
+      def explain(sha, tip)
+        return nil unless git.rev(sha) && git.rev(tip.sha)
+
+        git.explain(sha, tip.sha)
+      end
+
+      private
+
+      def root = @root ||= Git.new(@dir).toplevel || @dir
+      def git = Git.new(root)
+      def config = Setup::ProjectConfig.new(root)
+    end
+  end
+end

data/lib/fun_ci/trunk/merge_check.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "check"
+
+module FunCi
+  module Trunk
+    # What merging a commit with a trunk tip would do (architecture.md, Checking against the trunk,
+    # How the check works), from what git answers: the commits each side has
+    # that the other lacks, then, when both have some, a merge in memory.
+    class MergeCheck
+      # What a git command answered: its exit status and what it printed.
+      Answer = Data.define(:status, :out, :err)
+      # A merge stopped at its budget, with its process group.
+      OVER_BUDGET = Answer.new(status: :over_budget, out: "", err: "")
+      STOPPED = "the merge ran over its #{CHECK_BUDGET} s budget; " \
+                "set trunk: none in .fun-ci/config to stop checking".freeze
+
+      def initialize(git)
+        @git = git
+      end
+
+      # name: how the trunk is called in a reason, "origin/main".
+      def merge(commit, trunk, name)
+        counted = @git.counts(commit, trunk)
+        return Merge.unknown("git rev-list: #{first_line(counted)}") unless counted.status.zero?
+
+        ahead, behind = counted.out.split.map(&:to_i)
+        return Merge.clean(ahead: ahead, behind: behind) if ahead.zero? || behind.zero?
+
+        merged(@git.merge_tree(commit, trunk), name, ahead: ahead, behind: behind)
+      end
+
+      private
+
+      def merged(answer, name, **counts)
+        return Merge.unknown(STOPPED) if answer.equal?(OVER_BUDGET)
+        return Merge.clean(**counts) if answer.status.zero?
+        return Merge.conflicts(MergeOutput.parse(answer.out).paths, **counts) if answer.status == 1
+
+        Merge.unknown(reason(answer, name))
+      end
+
+      def reason(answer, name)
+        return "#{name} shares no history with this commit; set trunk: in .fun-ci/config" if unrelated?(answer)
+        return "needs git 2.38 or later; this is #{@git.version}" if answer.status == 129
+
+        "git merge-tree: #{first_line(answer)}"
+      end
+
+      def unrelated?(answer) = answer.err.include?("unrelated histories")
+      def first_line(answer) = answer.err.lines.first.to_s.chomp
+    end
+  end
+end

data/lib/fun_ci/trunk/regions.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Trunk
+    # The conflicted regions of a file as a merge leaves it (architecture.md, Checking against the trunk,
+    # why REV trunk): each conflict from its <<<<<<< line to its >>>>>>> line,
+    # with `around` lines either side, regions that touch joined into one.
+    module Regions
+      # Lines first to last, as [number, text] pairs, numbered from 1.
+      Region = Data.define(:first, :last, :lines)
+      AROUND = 3
+
+      def self.of(text, around: AROUND)
+        lines = text.lines(chomp: true)
+        spans = conflicts(lines).map { |from, to| [[from - around, 0].max, [to + around, lines.size - 1].min] }
+        joined(spans).map { |from, to| region(lines, from, to) }
+      end
+
+      def self.region(lines, from, to)
+        Region.new(first: from + 1, last: to + 1, lines: (from..to).map { |index| [index + 1, lines[index]] })
+      end
+
+      # [index of <<<<<<<, index of >>>>>>>] for each conflict.
+      def self.conflicts(lines)
+        marked = ->(marker) { lines.each_index.select { |index| lines[index].start_with?(marker) } }
+        marked.call("<<<<<<<").zip(marked.call(">>>>>>>"))
+      end
+
+      def self.joined(spans)
+        spans.each_with_object([]) do |(from, to), joined|
+          touching = joined.any? && from <= joined.last[1] + 1
+          touching ? joined[-1] = [joined.last[0], [joined.last[1], to].max] : joined << [from, to]
+        end
+      end
+      private_class_method :region, :conflicts, :joined
+    end
+  end
+end

data/lib/fun_ci/trunk/resolver.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Trunk
+    # A branch that may be the trunk: on a remote, or local when remote is nil.
+    Ref = Data.define(:remote, :branch)
+
+    class Ref
+      def to_s = remote ? "#{remote}/#{branch}" : branch
+    end
+
+    # What a repository has to choose a trunk from: its remotes, its branches
+    # (a remote's as "origin/main", local ones by name) and each remote's
+    # default branch, where git knows it.
+    Refs = Data.define(:remotes, :branches, :heads)
+
+    # Which ref is the trunk (architecture.md, Checking against the trunk):
+    # the one configured, else the remote's default branch, else the first
+    # usual trunk name on the remote, else locally; nil when none exists.
+    module Resolver
+      USUAL = %w[main master develop development trunk].freeze
+
+      def self.pick(setting, refs)
+        return configured(setting, refs.remotes) if setting
+
+        remote = remote(refs.remotes)
+        remote ? on_remote(remote, refs) : on_local(refs.branches)
+      end
+
+      # Why pick chose the trunk it did: :configured, :default (the remote's
+      # default branch), :usual (a usual trunk name on it) or :local.
+      def self.why(setting, refs)
+        return :configured if setting
+
+        remote = remote(refs.remotes)
+        return :local unless remote
+
+        refs.heads[remote] ? :default : :usual
+      end
+
+      def self.configured(setting, remotes)
+        remote = remotes.find { |name| setting.start_with?("#{name}/") }
+        Ref.new(remote: remote, branch: remote ? setting.delete_prefix("#{remote}/") : setting)
+      end
+
+      def self.remote(remotes)
+        return "origin" if remotes.include?("origin")
+
+        remotes.first if remotes.size == 1
+      end
+
+      def self.on_remote(remote, refs)
+        branch = refs.heads[remote] || USUAL.find { |name| refs.branches.include?("#{remote}/#{name}") }
+        branch && Ref.new(remote: remote, branch: branch)
+      end
+
+      def self.on_local(branches)
+        branch = USUAL.find { |name| branches.include?(name) }
+        branch && Ref.new(remote: nil, branch: branch)
+      end
+      private_class_method :configured, :remote, :on_remote, :on_local
+    end
+  end
+end

data/lib/fun_ci/trunk/shown.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "check"
+
+module FunCi
+  module Trunk
+    # A check as the developer and agents are shown it: its state, derived
+    # rather than stored, how many seconds ago its trunk tip was seen (nil
+    # when it had none), the project's last fetch (a LastFetch, nil if none), and
+    # the SHA the trunk has moved to since, if it has.
+    # A run whose check hasn't been recorded is checking until its fetch and
+    # merge are past their time, and then unknown.
+    Shown = Data.define(:state, :check, :age, :fetch, :moved_to)
+
+    class Shown
+      # How old a trunk may be before it is stale.
+      FRESH_FOR = 3600
+
+      def self.of(check, now:, fetch: nil, moved_to: nil)
+        new(state: state(check.merge), check: check, age: check.tip && (now - check.tip.seen_at),
+            fetch: fetch, moved_to: moved_to)
+      end
+
+      def self.unchecked(started:, now:)
+        if now - started <= FETCH_DEADLINE + CHECK_BUDGET
+          return new(state: "checking", check: nil, age: nil, fetch: nil, moved_to: nil)
+        end
+
+        of(Check.new(commit: nil, tip: nil, merge: Merge.unknown("the check never finished")), now: now)
+      end
+
+      def self.state(merge)
+        return merge.outcome if merge.outcome == "unknown"
+        return "in_trunk" if merge.ahead.zero?
+
+        merge.behind.zero? ? "up_to_date" : merge.outcome
+      end
+      private_class_method :state
+
+      # Whether the trunk it was checked against may have moved on unseen.
+      def stale? = !fetch_error.nil? || (!age.nil? && age > FRESH_FOR)
+
+      # Why the project's last fetch failed, or nil.
+      def fetch_error = fetch&.error
+    end
+  end
+end

data/lib/fun_ci/trunk/tip_reader.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "check"
+require_relative "fetch"
+require_relative "resolver"
+require_relative "../persistence/trunk_fetches"
+
+module FunCi
+  module Trunk
+    # The tip of the trunk a check reads, and when it counts as seen
+    # (architecture.md, Checking against the trunk): fun-ci's own ref once
+    # it has fetched one, seen when it was last fetched; else the developer's
+    # ref, seen when it last moved.
+    class TipReader
+      # clock: answers the time now.
+      def initialize(git, clock)
+        @git = git
+        @clock = clock
+      end
+
+      # fetching: whether fun-ci fetches this trunk; fetched: how this run's
+      # fetch went, if it made one; last: the fetch before it. Nil when the
+      # trunk doesn't exist.
+      def tip(ref, fetching:, fetched: nil, last: nil)
+        own = fetching && ref.remote && @git.rev(Fetch.ref_for(ref))
+        return at(ref, own, seen(fetched, last) || @git.moved_at(Fetch.ref_for(ref))) if own
+
+        full = ref.remote ? "refs/remotes/#{ref}" : "refs/heads/#{ref.branch}"
+        sha = @git.rev(full)
+        sha && at(ref, sha, @git.moved_at(full))
+      end
+
+      private
+
+      def seen(fetched, last) = fetched && !fetched.error ? @clock.call : last&.fetched_at
+      def at(ref, sha, seen_at) = Tip.new(remote: ref.remote, branch: ref.branch, sha: sha, seen_at: seen_at)
+    end
+  end
+end

data/lib/fun_ci/version.rb

@@ -2,5 +2,5 @@
 
 # Loaded on its own by the gemspec, so it must not require anything.
 module FunCi
-  VERSION = "2.0.1"
+  VERSION = "2.1.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fun_ci
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Erik Thyge Madsen
@@ -73,10 +73,12 @@ files:
 - lib/fun_ci/agent/exit_code.rb
 - lib/fun_ci/agent/git.rb
 - lib/fun_ci/agent/live_pipeline.rb
+- lib/fun_ci/agent/next_step.rb
 - lib/fun_ci/agent/options.rb
 - lib/fun_ci/agent/output.rb
 - lib/fun_ci/agent/report_stage.rb
 - lib/fun_ci/agent/reports.rb
+- lib/fun_ci/agent/run_details.rb
 - lib/fun_ci/agent/run_report.rb
 - lib/fun_ci/agent/runs_command.rb
 - lib/fun_ci/agent/runs_text.rb
@@ -86,6 +88,12 @@ files:
 - lib/fun_ci/agent/status_json.rb
 - lib/fun_ci/agent/status_text.rb
 - lib/fun_ci/agent/system_clock.rb
+- lib/fun_ci/agent/trunk_json.rb
+- lib/fun_ci/agent/trunk_reading.rb
+- lib/fun_ci/agent/trunk_text.rb
+- lib/fun_ci/agent/trunk_verdict.rb
+- lib/fun_ci/agent/trunk_why.rb
+- lib/fun_ci/agent/trunk_why_json.rb
 - lib/fun_ci/agent/verdict.rb
 - lib/fun_ci/agent/wait_command.rb
 - lib/fun_ci/agent/waiting.rb
@@ -96,6 +104,7 @@ files:
 - lib/fun_ci/cli_help.rb
 - lib/fun_ci/console/board_data.rb
 - lib/fun_ci/console/board_heartbeat.rb
+- lib/fun_ci/console/cancelled_folding.rb
 - lib/fun_ci/console/console_events.rb
 - lib/fun_ci/console/console_log.rb
 - lib/fun_ci/console/console_loop.rb
@@ -107,11 +116,14 @@ files:
 - lib/fun_ci/console/milestones.rb
 - lib/fun_ci/console/renderer_lookup.rb
 - lib/fun_ci/console/renderer_process.rb
+- lib/fun_ci/console/row_order.rb
 - lib/fun_ci/console/run_message.rb
 - lib/fun_ci/console/stage_change_detector.rb
 - lib/fun_ci/console/stage_events.rb
 - lib/fun_ci/console/stop_report.rb
 - lib/fun_ci/console/streak_counter.rb
+- lib/fun_ci/console/trunk_events.rb
+- lib/fun_ci/console/trunk_marks.rb
 - lib/fun_ci/console/view.rb
 - lib/fun_ci/evidence/about.rb
 - lib/fun_ci/evidence/about_stage.rb
@@ -205,6 +217,9 @@ files:
 - lib/fun_ci/persistence/run_status.rb
 - lib/fun_ci/persistence/stage_job.rb
 - lib/fun_ci/persistence/state_dir.rb
+- lib/fun_ci/persistence/trunk_checks.rb
+- lib/fun_ci/persistence/trunk_fetches.rb
+- lib/fun_ci/persistence/trunk_recording.rb
 - lib/fun_ci/persistence/write_trouble.rb
 - lib/fun_ci/pipeline/background_fork.rb
 - lib/fun_ci/pipeline/command_executor.rb
@@ -230,6 +245,7 @@ files:
 - lib/fun_ci/pipeline/trigger.rb
 - lib/fun_ci/pipeline/trigger_command.rb
 - lib/fun_ci/pipeline/trigger_params.rb
+- lib/fun_ci/pipeline/trunk_run.rb
 - lib/fun_ci/pipeline/workspaces.rb
 - lib/fun_ci/pipeline/worktree_pool.rb
 - lib/fun_ci/pipeline/worktree_prune.rb
@@ -237,10 +253,12 @@ files:
 - lib/fun_ci/setup/agent_instructions.rb
 - lib/fun_ci/setup/commands.rb
 - lib/fun_ci/setup/git_hooks.rb
+- lib/fun_ci/setup/gradle_linter_detector.rb
 - lib/fun_ci/setup/hook_script.rb
 - lib/fun_ci/setup/hook_writer.rb
 - lib/fun_ci/setup/installer.rb
 - lib/fun_ci/setup/legacy_hooks.rb
+- lib/fun_ci/setup/lint_detection.rb
 - lib/fun_ci/setup/maven_linter_detector.rb
 - lib/fun_ci/setup/project_config.rb
 - lib/fun_ci/setup/project_detector.rb
@@ -253,6 +271,19 @@ files:
 - lib/fun_ci/setup/stage_templates/scripting.rb
 - lib/fun_ci/setup/stage_templates/shell.rb
 - lib/fun_ci/setup/template_writer.rb
+- lib/fun_ci/setup/trunk_report.rb
+- lib/fun_ci/trunk/check.rb
+- lib/fun_ci/trunk/checker.rb
+- lib/fun_ci/trunk/description.rb
+- lib/fun_ci/trunk/fetch.rb
+- lib/fun_ci/trunk/first_fetch.rb
+- lib/fun_ci/trunk/git.rb
+- lib/fun_ci/trunk/local.rb
+- lib/fun_ci/trunk/merge_check.rb
+- lib/fun_ci/trunk/regions.rb
+- lib/fun_ci/trunk/resolver.rb
+- lib/fun_ci/trunk/shown.rb
+- lib/fun_ci/trunk/tip_reader.rb
 - lib/fun_ci/version.rb
 homepage: https://github.com/beatmadsen/fun-ci
 licenses: