fun_ci 2.3.0 → 2.4.0

data/lib/fun_ci/pipeline/process_tree.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Pipeline
+    # What to kill besides a stage's process groups: each process descended
+    # from one of their members, by parent id, that has left for a group or
+    # session of its own, as Node's detached children do. The rows must be
+    # read before the kill, since a killed parent's children move to init.
+    # A double-forked daemon has moved to init already and is not reached.
+    module ProcessTree
+      # Signal targets: -pid for an escapee leading its own group, which
+      # takes that group with it, and the pid alone of one in any other group.
+      def self.escaped(groups, rows)
+        escapees = outside(groups, descendants(in_groups(groups, rows), rows))
+        leaders = escapees.select { |row| row.pgid == row.pid }.map(&:pid)
+        leaders.map(&:-@) + escapees.reject { |row| leaders.include?(row.pgid) }.map(&:pid)
+      end
+
+      def self.in_groups(groups, rows) = rows.select { |row| groups.include?(row.pgid) }
+      def self.outside(groups, rows) = rows.reject { |row| groups.include?(row.pgid) }
+
+      # Bounded by the table's size, so a table whose parent ids form a cycle still ends.
+      def self.descendants(found, rows)
+        rows.size.times do
+          more = children(found.map(&:pid), rows) - found
+          return found if more.empty?
+
+          found += more
+        end
+        found
+      end
+
+      def self.children(parents, rows) = rows.select { |row| parents.include?(row.ppid) }
+      private_class_method :in_groups, :outside, :descendants, :children
+    end
+  end
+end

data/lib/fun_ci/pipeline/progress_reporter.rb

@@ -18,7 +18,8 @@ module FunCi
       end
 
       def cold_slot(seconds)
-        @stdout.puts "fun-ci: a new worktree, whose caches are empty, so lint and build have #{seconds}s this once."
+        @stdout.puts "fun-ci: a cold worktree (new, just cleaned, or unused for a day), so lint and build have " \
+                     "#{seconds}s this once."
       end
 
       def slow_launched

data/lib/fun_ci/pipeline/run_canceller.rb

@@ -5,18 +5,24 @@ require_relative "../persistence/active_jobs"
 require_relative "../persistence/run_status"
 require_relative "../persistence/write_trouble"
 require_relative "slot_lock"
+require_relative "process_tree"
+require_relative "../evidence/process_table"
 
 module FunCi
   module Pipeline
     # Stops every process of a run. The run's own processes go first, so none
     # of them records the run as failed once its stages die; then each stage's
-    # process group. A run whose slot nobody holds any more has died already,
+    # process group, and last what a stage started that left its group
+    # (ProcessTree). A run whose slot nobody holds any more has died already,
     # and the pids it recorded may belong to other processes now, so it is
     # left alone; so is this process.
     class RunCanceller
-      def initialize(killer: Process.method(:kill), slot_held: SlotLock.method(:held?))
+      # process_table: what ps lists now, as Evidence::ProcessTable rows.
+      def initialize(killer: Process.method(:kill), slot_held: SlotLock.method(:held?),
+                     process_table: Evidence::ProcessTable.method(:now))
         @killer = killer
         @slot_held = slot_held
+        @process_table = process_table
       end
 
       # Stops the run and records it, and its unfinished stages, cancelled.
@@ -60,11 +66,17 @@ module FunCi
       def stop(run)
         return unless alive?(run)
 
-        (run.processes - [Process.pid] + run.stage_groups.map(&:-@)).each { |pid| kill(pid) }
+        (run.processes - [Process.pid] + run.stage_groups.map(&:-@) + escaped(run)).each { |pid| kill(pid) }
       end
 
       private
 
+      def escaped(run)
+        return [] if run.stage_groups.empty?
+
+        ProcessTree.escaped(run.stage_groups, @process_table.call)
+      end
+
       # A stage its process started after `run` was read. A run's process
       # records a stage's group before it lets the stage start, so once those
       # processes are dead, looking again finds every stage they started.

data/lib/fun_ci/pipeline/stage_end.rb

@@ -58,7 +58,8 @@ module FunCi
         status = finished.status
         Evidence::Outcome.new(state: STATES.fetch(outcome(finished)), exit_status: status&.exitstatus,
                               signal: status&.termsig && Signal.signame(status.termsig),
-                              alongside: @recorder.alongside(@job_id), overrun: finished.overrun)
+                              alongside: @recorder.alongside(@job_id),
+                              elsewhere: @recorder.alongside_elsewhere(@job_id), overrun: finished.overrun)
       end
 
       def keep_exit(status)

data/lib/fun_ci/pipeline/workspaces.rb

@@ -15,7 +15,8 @@ module FunCi
       def self.for(project, sha)
         return InPlace.new(project) if sha == NULL_SHA
 
-        WorktreePool.new(Worktrees.new(project), size: Setup::ProjectConfig.new(project).worktree_slots)
+        config = Setup::ProjectConfig.new(project)
+        WorktreePool.new(Worktrees.new(project), size: config.worktree_slots, clean: config.clean)
       end
     end
   end

data/lib/fun_ci/pipeline/worktree_pool.rb

@@ -7,23 +7,33 @@ require_relative "worktrees"
 module FunCi
   module Pipeline
     # Hands each pipeline a worktree slot of its own under
-    # <git-common-dir>/fun-ci/worktrees, checked out at its commit, waiting
+    # Worktrees#root, checked out at its commit, waiting
     # while every slot is taken.
     class WorktreePool
       DEFAULT_SIZE = 2
+      # A slot nobody took for longer is cold: its caches are as warm as a
+      # run long ago left them, as a slot taken only when runs overlap is.
+      IDLE_SECONDS = 86_400
 
       attr_reader :size
 
-      def initialize(worktrees, size: DEFAULT_SIZE, waiter: -> { sleep 0.25 })
+      # Whether a slot last taken at `last_taken` has gone untaken too long.
+      def self.idle?(last_taken, now:) = now - last_taken > IDLE_SECONDS
+
+      # clean: the paths whose ignored files a slot loses when it moves off its
+      # line of history (Worktrees#check_out).
+      def initialize(worktrees, size: DEFAULT_SIZE, clean: [], waiter: -> { sleep 0.25 })
         @worktrees = worktrees
         @size = size
+        @clean = clean
         @waiter = waiter
       end
 
-      # A ColdSlot when the slot's worktree had to be made.
+      # A ColdSlot when the slot's worktree had to be made, or was cleaned, or
+      # nobody took the slot for a day.
       def acquire(sha)
         slot = wait_for_free_slot
-        @worktrees.check_out(slot.path, sha) ? slot.as_cold : slot
+        @worktrees.check_out(slot.path, sha, clean: @clean) ? slot.as_cold : slot
       rescue StandardError
         slot&.release
         raise
@@ -49,12 +59,19 @@ module FunCi
       # The lock stays open for as long as the slot is held, so no block.
       def try_lock(path)
         lock = File.new("#{path}.lock", File::RDWR | File::CREAT, 0o644)
-        return Slot.new(path, stamped(lock), lock.path) if lock.flock(File::LOCK_EX | File::LOCK_NB)
+        return taken(path, lock) if lock.flock(File::LOCK_EX | File::LOCK_NB)
 
         lock.close
         nil
       end
 
+      # Each taker stamps the lock, so its last change is when the slot was last taken.
+      def taken(path, lock)
+        idle = WorktreePool.idle?(lock.mtime, now: Time.now)
+        slot = Slot.new(path, stamped(lock), lock.path)
+        idle ? slot.as_cold : slot
+      end
+
       def stamped(lock)
         lock.truncate(0)
         lock.write(Process.pid.to_s)

data/lib/fun_ci/pipeline/worktree_prune.rb

@@ -6,8 +6,8 @@ require_relative "worktrees"
 module FunCi
   module Pipeline
     # Removes every slot of a project's worktree pool and every daily or
-    # weekly job's worktree, and git's entries for them, when no run or job
-    # holds one. It takes each slot's lock first, so a run
+    # weekly job's worktree, those an older fun-ci kept under the git
+    # directory too, and git's entries for them, when no run or job holds one. It takes each slot's lock first, so a run
     # starting meanwhile waits until the slot is gone and then checks it out
     # afresh.
     class WorktreePrune
@@ -43,8 +43,13 @@ module FunCi
       end
 
       def slot_paths
-        (Dir.glob(File.join(@worktrees.root, "slot-*")) + Dir.glob(File.join(@worktrees.jobs_root, "*")))
-          .map { |path| path.delete_suffix(".lock") }.uniq
+        patterns.flat_map { |pattern| Dir.glob(pattern) }.map { |path| path.delete_suffix(".lock") }.uniq
+      end
+
+      def patterns
+        legacy = @worktrees.legacy_dir
+        [File.join(@worktrees.root, "slot-*"), File.join(@worktrees.jobs_root, "*"),
+         File.join(legacy, "worktrees", "slot-*"), File.join(legacy, "jobs", "*")]
       end
     end
   end

data/lib/fun_ci/pipeline/worktrees.rb

@@ -1,16 +1,23 @@
 # frozen_string_literal: true
 
 require "open3"
+require "digest"
 require_relative "git_environment"
+require_relative "../persistence/state_dir"
 
 module FunCi
   module Pipeline
-    # The git commands a worktree slot needs, run against the project's repository.
+    # The git commands a worktree slot needs, run against the project's
+    # repository. The worktrees live in fun-ci's state directory, one place
+    # per repository (all its git worktrees share it), and not under .git/,
+    # which tools such as Vite refuse to serve files from.
     class Worktrees
       class GitError < StandardError; end
 
-      def initialize(project_root)
+      # state_dir: fun-ci's own (Persistence::StateDir).
+      def initialize(project_root, state_dir: Persistence::StateDir.path(ENV))
         @project_root = project_root
+        @state_dir = state_dir
       end
 
       def root = File.join(fun_ci_dir, "worktrees")
@@ -18,15 +25,25 @@ module FunCi
       # Where each daily and weekly job has a worktree of its own (Jobs::Locks).
       def jobs_root = File.join(fun_ci_dir, "jobs")
 
+      # Where fun-ci before 2.4 kept the worktrees: under the git directory.
+      def legacy_dir = File.join(common_dir, "fun-ci")
+
       # Leaves +path+ as a clean detached checkout of +sha+. Ignored files stay,
-      # so caches such as vendor/bundle survive between runs in the same slot.
-      # Answers whether it made the worktree, which then has no caches.
-      def check_out(path, sha)
+      # so caches such as vendor/bundle survive between runs in the same slot,
+      # except under the +clean+ paths when +sha+ doesn't descend from the
+      # slot's last commit: those are outputs only as right as the commit that
+      # made them. Answers whether the slot is cold: a worktree it made, which
+      # has no caches, or one it cleaned.
+      def check_out(path, sha, clean: [])
         return add(path, sha).then { true } unless File.exist?(File.join(path, ".git"))
 
+        moved_off = clean.any? && !descends?(path, sha)
         git(path, "checkout", "--detach", "--force", sha)
         git(path, "clean", "-fd")
-        false
+        return false unless moved_off
+
+        git(path, "clean", "-fdX", "--", *clean)
+        true
       end
 
       # Has git forget the worktrees whose directories are gone.
@@ -34,8 +51,22 @@ module FunCi
 
       private
 
+      # <state>/projects/<repository's name>-<digest of its git directory>.
       def fun_ci_dir
-        File.join(File.expand_path(git(@project_root, "rev-parse", "--git-common-dir").strip, @project_root), "fun-ci")
+        common = common_dir
+        name = File.basename(File.dirname(common))
+        File.join(@state_dir, "projects", "#{name}-#{Digest::SHA256.hexdigest(common)[0, 12]}")
+      end
+
+      def common_dir
+        File.realpath(File.expand_path(git(@project_root, "rev-parse", "--git-common-dir").strip, @project_root))
+      end
+
+      # Whether +sha+ descends from the commit checked out at +path+.
+      def descends?(path, sha)
+        last = git(path, "rev-parse", "HEAD").strip
+        _, status = Open3.capture2e(GitEnvironment::CLEAN, "git", "merge-base", "--is-ancestor", last, sha, chdir: path)
+        status.success?
       end
 
       def add(path, sha) = git(@project_root, "worktree", "add", "--detach", "--force", path, sha)

data/lib/fun_ci/setup/commands.rb

@@ -5,6 +5,7 @@ require_relative "hook_writer"
 require_relative "git_hooks"
 require_relative "setup_checker"
 require_relative "legacy_hooks"
+require_relative "init_options"
 
 module FunCi
   module Setup
@@ -18,13 +19,14 @@ module FunCi
       end
 
       def init(args)
-        code = Installer.run(project_root: @project_root, stdout: @stdout)
-        return code if !code.zero? || !args.include?("--everything")
-
-        code = install_hooks([])
-        return code unless code.zero?
-
-        check([])
+        options = InitOptions.parse(args)
+        code = Installer.run(project_root: @project_root, stdout: @stdout, stack: options.stack)
+        return code if !code.zero? || !options.everything
+
+        hooks_then_check
+      rescue InitOptions::Invalid => e
+        @stdout.puts "fun-ci init: #{e.message}"
+        64
       end
 
       def install_hooks(args)
@@ -38,6 +40,13 @@ module FunCi
 
       private
 
+      def hooks_then_check
+        code = install_hooks([])
+        return code unless code.zero?
+
+        check([])
+      end
+
       def install(types)
         hooks_dir = @hooks_dir.call(@project_root)
         types.each do |type|

data/lib/fun_ci/setup/eslint_detection.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "stage_templates"
+
+module FunCi
+  module Setup
+    # The build init writes for a JavaScript project that configures ESLint:
+    # the template's install, then ESLint, which loads what the install put
+    # in place, so it can't run in lint beside it (StageTemplates). nil keeps
+    # the template's build.
+    module EslintDetection
+      RUNNERS = { node_npm: "npx eslint .", node_pnpm: "pnpm exec eslint .", node_yarn: "yarn eslint .",
+                  bun: "bunx eslint ." }.freeze
+      CONFIGS = %w[eslint.config.js eslint.config.mjs eslint.config.cjs eslint.config.ts eslint.config.mts
+                   eslint.config.cts .eslintrc .eslintrc.js .eslintrc.cjs .eslintrc.json .eslintrc.yml
+                   .eslintrc.yaml].freeze
+
+      # names: the files at the project's top; package_json: its text.
+      def self.build(stack, names, package_json)
+        runner = RUNNERS[stack]
+        return nil unless runner && configured?(names, package_json)
+
+        "#{StageTemplates.scripts(stack)["build.sh"].lines.last.chomp} && #{runner}"
+      end
+
+      def self.configured?(names, package_json) = names.intersect?(CONFIGS) || in_package?(package_json)
+
+      def self.in_package?(text)
+        parsed = JSON.parse(text)
+        parsed.is_a?(Hash) && parsed.key?("eslintConfig")
+      rescue JSON::ParserError
+        false
+      end
+      private_class_method :configured?, :in_package?
+    end
+  end
+end

data/lib/fun_ci/setup/init_options.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module FunCi
+  module Setup
+    # The arguments of `fun-ci init [--everything] [--stack NAME]`.
+    module InitOptions
+      class Invalid < StandardError; end
+
+      Parsed = Data.define(:everything, :stack)
+
+      def self.parse(args)
+        values = { everything: false, stack: nil }
+        left = parser(values).parse(args)
+        raise Invalid, "takes no #{left.join(" ")}" if left.any?
+
+        Parsed.new(**values)
+      rescue OptionParser::ParseError => e
+        raise Invalid, e.message
+      end
+
+      # Long options only, without OptionParser's own --help and --version.
+      def self.parser(values)
+        parser = OptionParser.new
+        parser.base.long.clear
+        parser.on("--everything") { values[:everything] = true }
+        parser.on("--stack NAME") { |name| values[:stack] = name }
+        parser
+      end
+      private_class_method :parser
+    end
+  end
+end

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,10 +42,26 @@ 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
@@ -58,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/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

@@ -49,6 +49,7 @@ 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

data/lib/fun_ci/setup/settings.rb

@@ -43,6 +43,11 @@ module FunCi
       # and the jobs share the day evenly (Jobs::DueJobs).
       def job_spacing = seconds(setting("job_spacing"))
 
+      # 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 || []
+
       def errors
         setting_errors
       rescue Psych::SyntaxError => e
@@ -58,7 +63,7 @@ module FunCi
       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].compact
+        [slots_error, spacing_error, clean_error].compact
       end
 
       # The slots the file asks for, when that is a whole number above 0.
@@ -80,6 +85,21 @@ module FunCi
         ".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::Exception

data/lib/fun_ci/setup/setup_checker.rb

@@ -4,19 +4,21 @@ 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
-      # The hooks it warns of: fun-ci 1.x's, and any in `hooks_dir` that
-      # doesn't run fun-ci.
+      # 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)
-        hooks = Hooks.new([LegacyHooks.new(project_root), InstalledHooks.new(hooks_dir)])
+        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

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