fun_ci 2.2.0 → 2.4.0

data/lib/fun_ci/setup/installer.rb

@@ -3,6 +3,8 @@
 require_relative "project_detector"
 require_relative "template_writer"
 require_relative "lint_detection"
+require_relative "eslint_detection"
+require_relative "stage_templates"
 require_relative "agent_instructions"
 
 module FunCi
@@ -14,13 +16,18 @@ module FunCi
                       "Then fast.sh runs beside slow.sh, both on what build.sh built: have build.sh " \
                       "compile everything they need, test code included."].freeze
 
-      def self.run(project_root:, stdout: $stdout)
-        new(project_root: project_root, stdout: stdout).run
+      PLACEHOLDERS = "Could not detect the project type, so .fun-ci/ has placeholder scripts that pass and " \
+                     "test nothing: put the project's own commands in them, or start again with --stack NAME."
+
+      # stack: a name of ProjectDetector::STACKS to write in place of the one detected.
+      def self.run(project_root:, stdout: $stdout, stack: nil)
+        new(project_root: project_root, stdout: stdout, stack: stack).run
       end
 
-      def initialize(project_root:, stdout:)
+      def initialize(project_root:, stdout:, stack:)
         @project_root = project_root
         @stdout = stdout
+        @stack = stack
       end
 
       # A project set up for fun-ci, new or not, also tells agents what to do.
@@ -35,20 +42,37 @@ module FunCi
       def set_up
         return report(".fun-ci/ already exists, so init left it as it is.", 0) if initialised?
 
-        detected = ProjectDetector.new(Dir.children(@project_root)).detect
-        return report("Could not detect project type. Create .fun-ci/ manually.", 1) if detected == :unknown
+        stack = chosen_stack
+        return unknown_stack if stack.nil?
+        return write_placeholders if stack == :unknown
+
+        write_templates(stack)
+      end
+
+      def chosen_stack
+        return ProjectDetector.new(Dir.children(@project_root)).detect if @stack.nil?
+
+        ProjectDetector::STACKS.keys.find { |stack| stack.to_s == @stack }
+      end
+
+      def unknown_stack
+        report("fun-ci init: no stack named #{@stack}; the stacks are #{ProjectDetector::STACKS.keys.join(", ")}", 64)
+      end
 
-        write_templates(detected)
+      def write_placeholders
+        TemplateWriter.new(StageTemplates::PLACEHOLDERS, @project_root).write
+        report(PLACEHOLDERS, 0)
       end
 
       def tell_agents
         file = AgentInstructions.file_for(Dir.children(@project_root))
         path = File.join(@project_root, file)
-        merged = AgentInstructions.merged(File.exist?(path) ? File.read(path) : "")
+        told = File.exist?(path) ? File.read(path) : ""
+        merged = AgentInstructions.merged(told)
         return unless merged
 
         File.write(path, merged)
-        @stdout.puts "Told agents what to do after a commit, in #{file}."
+        @stdout.puts AgentInstructions.said(told, file)
       end
 
       def initialised?
@@ -57,11 +81,22 @@ module FunCi
 
       def write_templates(detected)
         @stdout.puts "Detected: #{detected.to_s.tr("_", " ")}"
-        TemplateWriter.new(detected, @project_root, lint_override: LintDetection.command(detected, @project_root)).write
+        TemplateWriter.new(scripts_for(detected), @project_root).write
         @stdout.puts "Created .fun-ci/ with template scripts.", *SIDE_BY_SIDE
         0
       end
 
+      def scripts_for(detected)
+        StageTemplates.scripts(detected, lint_override: LintDetection.command(detected, @project_root),
+                                         build_override: EslintDetection.build(detected, Dir.children(@project_root),
+                                                                               package_json))
+      end
+
+      def package_json
+        path = File.join(@project_root, "package.json")
+        File.exist?(path) ? File.read(path) : "{}"
+      end
+
       def report(message, exit_code)
         @stdout.puts message
         exit_code

data/lib/fun_ci/setup/lfs_hook.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "hook_script"
+
+module FunCi
+  module Setup
+    # git-lfs's own post-commit and pre-push hooks, as `git lfs install`
+    # writes them, and the hook fun-ci writes in their place, which runs
+    # fun-ci's, then git-lfs's. A push reads its ref list from git once, so
+    # the pre-push hook keeps it in a file and gives it to both.
+    module LfsHook
+      GUARD = %r{\Acommand -v git-lfs >/dev/null 2>&1 \|\| \{.*; exit 2; \}\z}
+      MISSING = %(command -v git-lfs >/dev/null 2>&1 || { echo "This repository is configured for Git LFS ) +
+                %(but 'git-lfs' was not found on your path." >&2; exit 2; })
+
+      RUN = {
+        "post-commit" => "if #{HookScript::INSTALLED}; then fun_ci; else #{HookScript::NOT_INSTALLED}; fi\n",
+        "pre-push" => %(if #{HookScript::INSTALLED}; then fun_ci < "$refs" || exit 1; ) +
+                      "else #{HookScript::NOT_INSTALLED}; fi\n"
+      }.freeze
+
+      KEEP_REFS = { "post-commit" => "", "pre-push" => <<~SH }.freeze
+        refs=$(mktemp) || exit 1
+        trap 'rm -f "$refs"' EXIT
+        cat > "$refs"
+      SH
+
+      FUN_CI = { "post-commit" => HookScript::POST_COMMIT, "pre-push" => "#{HookScript::PRE_PUSH_WAITS}return $status\n" }
+               .freeze
+      LFS_INPUT = { "post-commit" => "", "pre-push" => %( < "$refs") }.freeze
+
+      # Whether `script` is the hook `git lfs install` writes for `hook_type`
+      # and nothing more.
+      def self.stock?(script, hook_type)
+        lines = script.lines(chomp: true).reject { |line| line.strip.empty? }
+        lines.size == 3 && lines.first == "#!/bin/sh" && GUARD.match?(lines[1]) && lines.last == call(hook_type)
+      end
+
+      def self.runs_lfs?(script, hook_type) = script.include?(call(hook_type))
+
+      def self.script(hook_type)
+        "#!/bin/sh\n#{HookScript::MARKER}\n# fun-ci's #{hook_type} hook, then git-lfs's, which it replaced.\n" \
+          "#{KEEP_REFS.fetch(hook_type)}fun_ci() {\n#{FUN_CI.fetch(hook_type)}}\n" \
+          "#{RUN.fetch(hook_type)}#{MISSING}\n#{call(hook_type)}#{LFS_INPUT.fetch(hook_type)}\n"
+      end
+
+      def self.call(hook_type) = %(git lfs #{hook_type} "$@")
+    end
+  end
+end

data/lib/fun_ci/setup/placeholders.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "stage_templates"
+
+module FunCi
+  module Setup
+    # The stage scripts in .fun-ci/ that are still init's placeholders, as
+    # `fun-ci check`'s warnings.
+    class Placeholders
+      STAGES = %w[lint build fast slow].freeze
+
+      def initialize(project_root)
+        @dir = File.join(project_root, ".fun-ci")
+      end
+
+      def warnings = STAGES.select { |stage| placeholder?(stage) }.map { |stage| warning(stage) }
+
+      private
+
+      def placeholder?(stage)
+        path = File.join(@dir, "#{stage}.sh")
+        File.file?(path) && File.read(path).include?(StageTemplates::MARKER)
+      end
+
+      def warning(stage)
+        ".fun-ci/#{stage}.sh is init's placeholder, so the #{stage} stage tests nothing: put the project's own in it"
+      end
+    end
+  end
+end

data/lib/fun_ci/setup/project_config.rb

@@ -20,12 +20,17 @@ module FunCi
         Dir.exist?(@fun_ci_dir)
       end
 
+      # What stops a pipeline: no .fun-ci/, or a stage script it can't run.
       def validate
         return ["No .fun-ci/ folder found in #{@project_root}"] unless folder_exists?
 
-        REQUIRED_SCRIPTS.flat_map { |script| script_errors(script) } + settings.errors
+        REQUIRED_SCRIPTS.flat_map { |script| script_errors(script) }
       end
 
+      # Mistakes in .fun-ci/config, which never stop a pipeline: the setting
+      # takes its default instead.
+      def settings_errors = settings.errors
+
       # Mistakes in the `evidence` key, which `fun-ci check` reports but which
       # never stop a pipeline: the entry with the mistake is left out instead.
       def evidence_errors = Evidence::Settings.load(File.join(@fun_ci_dir, "config")).errors(root: @project_root)
@@ -44,8 +49,10 @@ module FunCi
       def job_errors = Jobs::Folders.new(@project_root).errors
 
       def worktree_slots = settings.worktree_slots
+      def clean = settings.clean
       def trunk = settings.trunk
       def trunk_fetch = settings.trunk_fetch
+      def job_spacing = settings.job_spacing
 
       def script_path(stage)
         File.join(@fun_ci_dir, "#{stage}.sh")

data/lib/fun_ci/setup/settings.rb

@@ -6,7 +6,8 @@ module FunCi
   module Setup
     # .fun-ci/config: settings for this machine's runs, as YAML. Each one left
     # out takes its default; one that is wrong is reported and the default used,
-    # as are all of them when the file isn't YAML.
+    # as are all of them when the file can't be read as YAML. Anchors and
+    # aliases are YAML, so they are read.
     class Settings
       DEFAULTS = { "worktree_slots" => 2 }.freeze
       FETCH_EVERY = 300
@@ -20,7 +21,7 @@ module FunCi
         @text = text
       end
 
-      def worktree_slots = errors.empty? ? values.fetch("worktree_slots") : DEFAULTS.fetch("worktree_slots")
+      def worktree_slots = slots || DEFAULTS.fetch("worktree_slots")
 
       # The trunk's name, or nil when none is given or it is no name. A mistake
       # in the trunk settings never stops a pipeline, so none is among `errors`.
@@ -37,22 +38,71 @@ module FunCi
         seconds(given) || FETCH_EVERY
       end
 
-      def errors
-        return [".fun-ci/config must be a mapping such as `worktree_slots: 2`"] unless raw.is_a?(Hash)
+      # Seconds between the starts of the jobs a commit starts, 0 for all at
+      # once (Jobs::Schedule); nil when none is given, or none it can read,
+      # and the jobs share the day evenly (Jobs::DueJobs).
+      def job_spacing = seconds(setting("job_spacing"))
 
-        slots = values["worktree_slots"]
-        return [] if slots.is_a?(Integer) && slots.positive?
+      # The paths, inside the project, whose git-ignored files a slot loses
+      # when it moves off its line of history (Pipeline::Worktrees); none
+      # when none are given, or what is given is no such list.
+      def clean = cleaned || []
 
-        [".fun-ci/config: worktree_slots must be a whole number above 0, not #{slots.inspect}"]
+      def errors
+        setting_errors
       rescue Psych::SyntaxError => e
         [".fun-ci/config is not YAML: #{e.problem} (line #{e.line})"]
+      rescue Psych::DisallowedClass => e
+        [".fun-ci/config can't be read: #{e.message} (quote a value such as a date to read it as text)"]
+      rescue Psych::Exception => e
+        [".fun-ci/config can't be read: #{e.message}"]
       end
 
       private
 
+      def setting_errors
+        return [".fun-ci/config must be a mapping such as `worktree_slots: 2`"] unless raw.is_a?(Hash)
+
+        [slots_error, spacing_error, clean_error].compact
+      end
+
+      # The slots the file asks for, when that is a whole number above 0.
+      def slots
+        given = setting("worktree_slots")
+        given if given.is_a?(Integer) && given.positive?
+      end
+
+      def slots_error
+        given = setting("worktree_slots")
+        ".fun-ci/config: worktree_slots must be a whole number above 0, not #{given.inspect}" unless given.nil? || slots
+      end
+
+      # Unlike the trunk's, since taking turns is the jobs' whole point (AT-13.28).
+      def spacing_error
+        given = setting("job_spacing")
+        return nil if given.nil? || seconds(given)
+
+        ".fun-ci/config: job_spacing must be seconds, or a number with s, m or h, not #{given.inspect}"
+      end
+
+      def cleaned
+        given = setting("clean")
+        given if given.is_a?(Array) && given.all? { |path| inside?(path) }
+      end
+
+      def inside?(path) = path.is_a?(String) && !path.start_with?("/") && !path.split("/").include?("..")
+
+      def clean_error
+        given = setting("clean")
+        return nil if given.nil? || cleaned
+
+        ".fun-ci/config: clean must be a list of paths inside the project, such as [public/assets], " \
+          "not #{given.inspect}"
+      end
+
       def setting(key)
         raw.is_a?(Hash) ? raw[key] : nil
-      rescue Psych::SyntaxError
+      rescue Psych::Exception
         nil
       end
 
@@ -61,8 +111,7 @@ module FunCi
         match && (match[1].to_i * UNITS.fetch(match[2]))
       end
 
-      def raw = (@text && YAML.safe_load(@text)) || {}
-      def values = DEFAULTS.merge(raw)
+      def raw = (@text && YAML.safe_load(@text, aliases: true)) || {}
     end
   end
 end

data/lib/fun_ci/setup/setup_checker.rb

@@ -2,13 +2,24 @@
 
 require_relative "project_config"
 require_relative "legacy_hooks"
+require_relative "installed_hooks"
 require_relative "trunk_report"
+require_relative "placeholders"
 
 module FunCi
   module Setup
     class SetupChecker
-      def self.run(project_root:, stdout: $stdout)
-        new(config: ProjectConfig.new(project_root), hooks: LegacyHooks.new(project_root), stdout: stdout,
+      # What it warns of: fun-ci 1.x's hooks, any in `hooks_dir` that doesn't
+      # run fun-ci, and stage scripts still init's placeholders.
+      Hooks = Data.define(:sources) do
+        def warnings = sources.flat_map(&:warnings)
+      end
+
+      # hooks_dir: where git runs the project's hooks from; nil outside a git repository.
+      def self.run(project_root:, stdout: $stdout, hooks_dir: nil)
+        sources = [LegacyHooks.new(project_root), InstalledHooks.new(hooks_dir), Placeholders.new(project_root)]
+        hooks = Hooks.new(sources)
+        new(config: ProjectConfig.new(project_root), hooks: hooks, stdout: stdout,
             trunk: TrunkReport.new(project_root)).run
       end
 
@@ -22,7 +33,7 @@ module FunCi
 
       # Warnings are printed but don't fail the check.
       def run
-        errors = @config.validate + @config.evidence_errors + @config.job_errors
+        errors = problems
         @stdout.puts(errors.empty? ? "All OK. The project is configured." : errors)
         @stdout.puts(@trunk.lines)
         list_presets
@@ -33,6 +44,8 @@ module FunCi
 
       private
 
+      def problems = @config.validate + @config.settings_errors + @config.evidence_errors + @config.job_errors
+
       def list_presets
         lists = { "this project" => @config.presets, "any project's output" => @config.any_project_presets }
         lists.each { |what, names| @stdout.puts "Evidence presets for #{what}: #{names.join(", ")}" if names.any? }

data/lib/fun_ci/setup/stage_templates/javascript.rb

@@ -5,13 +5,23 @@ require_relative "shell"
 module FunCi
   module Setup
     # JavaScript and TypeScript: Deno, Bun, and Node with its package managers.
+    # Lint runs beside the build, which installs the packages, so it checks
+    # the source alone: a linter that loads them, ESLint, goes in the build
+    # after the install (EslintDetection). Deno's lint needs no packages.
     module StageTemplates
+      SOURCES = "find . -name node_modules -prune -o -name .git -prune -o -type f"
+      NODE_CHECK = "#{SOURCES} \\( -name '*.js' -o -name '*.mjs' -o -name '*.cjs' \\) -print | " \
+                   'while read -r file; do node --check "$file" || exit 1; done'.freeze
+      BUN_CHECK = "#{SOURCES} \\( -name '*.js' -o -name '*.mjs' -o -name '*.cjs' -o -name '*.ts' " \
+                  "-o -name '*.tsx' \\) -print | " \
+                  'while read -r file; do bun build --no-bundle "$file" > /dev/null || exit 1; done'.freeze
+
       JAVASCRIPT = {
         deno: stages("deno lint", "deno check", "deno test", "deno task test:slow"),
-        bun: stages("bunx eslint .", "bun install", "bun test", "bun run test:slow"),
-        node_pnpm: stages("pnpm exec eslint .", "pnpm install", "pnpm test", "pnpm run test:slow"),
-        node_yarn: stages("yarn eslint .", "yarn install", "yarn test", "yarn run test:slow"),
-        node_npm: stages("npx eslint .", "npm install", "npm test", "npm run test:slow")
+        bun: stages(BUN_CHECK, "bun install", "bun test", "bun run test:slow"),
+        node_pnpm: stages(NODE_CHECK, "pnpm install", "pnpm test", "pnpm run test:slow"),
+        node_yarn: stages(NODE_CHECK, "yarn install", "yarn test", "yarn run test:slow"),
+        node_npm: stages(NODE_CHECK, "npm install", "npm test", "npm run test:slow")
       }.freeze
     end
   end

data/lib/fun_ci/setup/stage_templates/placeholders.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "shell"
+
+module FunCi
+  module Setup
+    # The scripts `fun-ci init` writes where it knows no stack: each passes,
+    # says it tests nothing, and carries MARKER, by which `fun-ci check` warns
+    # of it until the project's own command takes its place.
+    module StageTemplates
+      MARKER = "# fun-ci placeholder"
+
+      def self.placeholder(stage)
+        "#{MARKER}: init knew no stack here, so put the project's #{stage} in place of this.\n" \
+          "echo \"fun-ci: .fun-ci/#{stage}.sh is init's placeholder and tests nothing\""
+      end
+
+      PLACEHOLDERS = stages(*%w[lint build fast slow].map { |stage| placeholder(stage) }).freeze
+    end
+  end
+end

data/lib/fun_ci/setup/stage_templates.rb

@@ -4,6 +4,7 @@ require_relative "stage_templates/managed"
 require_relative "stage_templates/native"
 require_relative "stage_templates/scripting"
 require_relative "stage_templates/javascript"
+require_relative "stage_templates/placeholders"
 
 module FunCi
   module Setup
@@ -15,10 +16,11 @@ module FunCi
     module StageTemplates
       TEMPLATES = [MANAGED, NATIVE, SCRIPTING, JAVASCRIPT].reduce(:merge).freeze
 
-      # { "lint.sh" => script, ... }; +lint_override+ replaces the lint command.
-      def self.scripts(template_id, lint_override: nil)
-        scripts = TEMPLATES.fetch(template_id)
-        lint_override ? scripts.merge("lint.sh" => script("lint.sh", lint_override)) : scripts
+      # { "lint.sh" => script, ... }; +lint_override+ and +build_override+
+      # replace the lint and build commands.
+      def self.scripts(template_id, lint_override: nil, build_override: nil)
+        overrides = { "lint.sh" => lint_override, "build.sh" => build_override }.compact
+        TEMPLATES.fetch(template_id).merge(overrides.to_h { |name, command| [name, script(name, command)] })
       end
     end
   end

data/lib/fun_ci/setup/template_writer.rb

@@ -1,13 +1,11 @@
 # frozen_string_literal: true
 
-require_relative "stage_templates"
-
 module FunCi
   module Setup
-    # Writes a project's .fun-ci/ stage scripts, executable.
+    # Writes a project's .fun-ci/ stage scripts, executable: scripts is { "lint.sh" => script, ... }.
     class TemplateWriter
-      def initialize(template_id, target_dir, lint_override: nil)
-        @scripts = StageTemplates.scripts(template_id, lint_override: lint_override)
+      def initialize(scripts, target_dir)
+        @scripts = scripts
         @target_dir = target_dir
       end
 

data/lib/fun_ci/trunk/shown.rb

@@ -8,8 +8,9 @@ module FunCi
     # 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.
+    # A run whose check hasn't been recorded is checking while its foreground
+    # stages run and until its fetch and merge are past their time, and then
+    # unknown.
     Shown = Data.define(:state, :check, :age, :fetch, :moved_to)
 
     class Shown
@@ -21,8 +22,10 @@ module FunCi
             fetch: fetch, moved_to: moved_to)
       end
 
-      def self.unchecked(started:, now:)
-        if now - started <= FETCH_DEADLINE + CHECK_BUDGET
+      # stages_running: whether the run's foreground stages, which the check
+      # is recorded after, are still going.
+      def self.unchecked(started:, now:, stages_running: false)
+        if stages_running || now - started <= FETCH_DEADLINE + CHECK_BUDGET
           return new(state: "checking", check: nil, age: nil, fetch: nil, moved_to: nil)
         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.2.0"
+  VERSION = "2.4.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fun_ci
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.4.0
 platform: ruby
 authors:
 - Erik Thyge Madsen
@@ -63,6 +63,7 @@ files:
 - exe/fun-ci
 - lib/fun_ci.rb
 - lib/fun_ci/agent/age.rb
+- lib/fun_ci/agent/cancel_command.rb
 - lib/fun_ci/agent/command_support.rb
 - lib/fun_ci/agent/commands.rb
 - lib/fun_ci/agent/context.rb
@@ -94,6 +95,7 @@ files:
 - lib/fun_ci/agent/snapshots.rb
 - lib/fun_ci/agent/span.rb
 - lib/fun_ci/agent/stage_summary.rb
+- lib/fun_ci/agent/starts_in.rb
 - lib/fun_ci/agent/status_command.rb
 - lib/fun_ci/agent/status_json.rb
 - lib/fun_ci/agent/status_text.rb
@@ -111,6 +113,7 @@ files:
 - lib/fun_ci/agent/why_json.rb
 - lib/fun_ci/agent/why_text.rb
 - lib/fun_ci/cli.rb
+- lib/fun_ci/cli_command_help.rb
 - lib/fun_ci/cli_help.rb
 - lib/fun_ci/console/board_data.rb
 - lib/fun_ci/console/board_heartbeat.rb
@@ -226,12 +229,15 @@ files:
 - lib/fun_ci/jobs/job_fork.rb
 - lib/fun_ci/jobs/job_run.rb
 - lib/fun_ci/jobs/locks.rb
+- lib/fun_ci/jobs/schedule.rb
 - lib/fun_ci/jobs/site.rb
 - lib/fun_ci/jobs/standings.rb
 - lib/fun_ci/jobs/state.rb
+- lib/fun_ci/jobs/wall_clock_wait.rb
 - lib/fun_ci/persistence/active_jobs.rb
 - lib/fun_ci/persistence/active_runs.rb
 - lib/fun_ci/persistence/database.rb
+- lib/fun_ci/persistence/died.rb
 - lib/fun_ci/persistence/job_recorder.rb
 - lib/fun_ci/persistence/job_runs.rb
 - lib/fun_ci/persistence/null_recorder.rb
@@ -249,14 +255,18 @@ files:
 - 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/budgets.rb
 - lib/fun_ci/pipeline/command_executor.rb
 - lib/fun_ci/pipeline/gate.rb
 - lib/fun_ci/pipeline/git_environment.rb
+- lib/fun_ci/pipeline/group_kill.rb
 - lib/fun_ci/pipeline/head_part.rb
 - lib/fun_ci/pipeline/in_place.rb
 - lib/fun_ci/pipeline/output_window.rb
 - lib/fun_ci/pipeline/pipeline_forker.rb
+- lib/fun_ci/pipeline/priorities.rb
 - lib/fun_ci/pipeline/process_runner.rb
+- lib/fun_ci/pipeline/process_tree.rb
 - lib/fun_ci/pipeline/progress_reporter.rb
 - lib/fun_ci/pipeline/run_canceller.rb
 - lib/fun_ci/pipeline/slot.rb
@@ -279,14 +289,19 @@ files:
 - lib/fun_ci/pipeline/worktrees.rb
 - lib/fun_ci/setup/agent_instructions.rb
 - lib/fun_ci/setup/commands.rb
+- lib/fun_ci/setup/eslint_detection.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/init_options.rb
+- lib/fun_ci/setup/installed_hooks.rb
 - lib/fun_ci/setup/installer.rb
 - lib/fun_ci/setup/legacy_hooks.rb
+- lib/fun_ci/setup/lfs_hook.rb
 - lib/fun_ci/setup/lint_detection.rb
 - lib/fun_ci/setup/maven_linter_detector.rb
+- lib/fun_ci/setup/placeholders.rb
 - lib/fun_ci/setup/project_config.rb
 - lib/fun_ci/setup/project_detector.rb
 - lib/fun_ci/setup/settings.rb
@@ -295,6 +310,7 @@ files:
 - lib/fun_ci/setup/stage_templates/javascript.rb
 - lib/fun_ci/setup/stage_templates/managed.rb
 - lib/fun_ci/setup/stage_templates/native.rb
+- lib/fun_ci/setup/stage_templates/placeholders.rb
 - lib/fun_ci/setup/stage_templates/scripting.rb
 - lib/fun_ci/setup/stage_templates/shell.rb
 - lib/fun_ci/setup/template_writer.rb