kettle-jem 7.0.0 → 7.1.3

data/lib/kettle/jem/tasks/prepare_task.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+require "bundler"
+require "kettle/dev/lockfile_reset"
+require "pathname"
+require "shellwords"
+
+module Kettle
+  module Jem
+    module Tasks
+      module PrepareTask
+        PREPARE_ONLY_PATHS = [
+          Kettle::Jem::KETTLE_CONFIG_PATH,
+          "Gemfile",
+          # Gemfile evaluates these fragments immediately.  Preparing only the
+          # templating pair leaves a newly migrated project with references to
+          # files that do not exist yet, so Bundler cannot perform the bootstrap.
+          "gemfiles/modular/**",
+          "mise.toml"
+        ].freeze
+        CRITICAL_TEMPLATING_GEMS = %w[nomono].freeze
+        LOCKED_TEMPLATING_GEMS = %w[tree_sitter_language_pack].freeze
+
+        module_function
+
+        def run(project_root: Dir.pwd, env: ENV, run_options: {}, command_runner: Kettle::Jem::Tasks::InstallTask.method(:run_system_command))
+          effective_run_options = Kettle::Jem::Tasks::TemplateTask.env_run_options(env || {}).merge(run_options || {})
+          prepare_run_options = effective_run_options.merge(
+            only: PREPARE_ONLY_PATHS,
+            skip_lock_normalization: true
+          )
+          events = Kettle::Jem.event_stream_from_options(effective_run_options)
+          report = Kettle::Jem.apply_project(project_root, env: env, run_options: prepare_run_options)
+          profile_sync_step = synchronize_monorepo_subgem_profile_step(project_root, report)
+          supplemental_report = if profile_sync_step && profile_sync_step.fetch(:status) == "applied"
+            Kettle::Jem.apply_project(project_root, env: env, run_options: prepare_run_options)
+          end
+          report = merge_supplemental_prepare_report(report, supplemental_report)
+          nomono_bootstrap_step = normalize_existing_local_gemfile_bootstraps_step(project_root, events: events)
+          setup_env = Kettle::Jem::Tasks::InstallTask.setup_command_env(project_root, env)
+          setup_env["BUNDLE_DISABLE_CHECKSUM_VALIDATION"] = "true"
+          setup_env["K_JEM_TEMPLATING"] = "true" if local_path_development_env?(env)
+          reset_step = reset_release_lockfiles_step(
+            project_root: project_root,
+            setup_env: setup_env,
+            quiet: Kettle::Jem::DecisionPolicy.value_to_boolean(effective_run_options[:quiet]),
+            command_runner: command_runner,
+            events: events
+          )
+          Kettle::Jem.emit_step_event(events, "command_step", reset_step, phase: "prepare")
+          bootstrap_name = templating_bootstrap_step_name(project_root)
+          bootstrap_command = templating_bootstrap_command(project_root)
+          Kettle::Jem.emit_step_event(
+            events,
+            "command_step",
+            {name: bootstrap_name, status: "started", command: bootstrap_command},
+            phase: "prepare"
+          )
+          bootstrap_step = Kettle::Jem::Tasks::InstallTask.run_command_step(
+            bootstrap_name,
+            bootstrap_command,
+            project_root: project_root,
+            env: setup_env,
+            quiet: Kettle::Jem::DecisionPolicy.value_to_boolean(effective_run_options[:quiet]),
+            command_runner: command_runner
+          )
+          Kettle::Jem.emit_step_event(events, "command_step", bootstrap_step, phase: "prepare")
+          bundle_step = bundle_install_after_bootstrap_step(
+            project_root: project_root,
+            setup_env: setup_env,
+            quiet: Kettle::Jem::DecisionPolicy.value_to_boolean(effective_run_options[:quiet]),
+            command_runner: command_runner,
+            events: events,
+            bootstrap_command: bootstrap_command
+          )
+          Kettle::Jem.emit_step_event(events, "command_step", bundle_step, phase: "prepare")
+
+          final_report = report.merge(
+            mode: "prepare",
+            prepared: bootstrap_step.fetch(:status) == "succeeded" &&
+              %w[skipped succeeded].include?(reset_step.fetch(:status)) &&
+              %w[skipped succeeded].include?(bundle_step.fetch(:status)),
+            prepare_only: PREPARE_ONLY_PATHS,
+            prepare_steps: [profile_sync_step, nomono_bootstrap_step, reset_step, bootstrap_step, bundle_step].compact,
+            changed_files: (
+              report.fetch(:changed_files, []) +
+                nomono_bootstrap_step.fetch(:changed_files, []) +
+                reset_step.fetch(:changed_files, []) +
+                bootstrap_step.fetch(:changed_files, []) +
+                bundle_step.fetch(:changed_files, [])
+            ).uniq.sort,
+            diagnostics: report.fetch(:diagnostics, []) + [{
+              severity: "advisory",
+              message: "kettle:jem:prepare applied the templating dependency bootstrap payload, " \
+                "updated critical templating gems, and ran bundle install."
+            }]
+          )
+          Kettle::Jem.emit_summary_event(events, final_report)
+          final_report
+        end
+
+        def synchronize_monorepo_subgem_profile_step(project_root, report)
+          facts = report.fetch(:facts, {})
+          return unless Kettle::Jem.send(:monorepo_subgem_template_profile?, facts)
+
+          Kettle::Jem.send(:monorepo_subgem_kettle_config_profile_sync_step, project_root, report)
+        end
+
+        def merge_supplemental_prepare_report(report, supplemental_report)
+          return report unless supplemental_report
+
+          report.merge(
+            changed_files: (
+              report.fetch(:changed_files, []) + supplemental_report.fetch(:changed_files, [])
+            ).uniq.sort,
+            diagnostics: report.fetch(:diagnostics, []) + supplemental_report.fetch(:diagnostics, [])
+          )
+        end
+
+        def normalize_existing_local_gemfile_bootstraps_step(project_root, events:)
+          paths = Dir.glob(File.join(project_root.to_s, "gemfiles/modular/**/*_local.gemfile")).sort
+          changed_files = paths.filter_map do |path|
+            before = File.read(path)
+            after = Kettle::Jem.normalize_local_gemfile_nomono_bootstrap(before)
+            next if after == before
+
+            File.write(path, after)
+            Pathname.new(path).relative_path_from(Pathname.new(project_root.to_s)).to_s
+          end
+          step = {
+            name: "normalize_local_gemfile_bootstraps",
+            status: changed_files.empty? ? "already_current" : "applied",
+            changed_files: changed_files
+          }
+          Kettle::Jem.emit_step_event(events, "command_step", step, phase: "prepare")
+          step
+        end
+
+        def reset_release_lockfiles_step(project_root:, setup_env:, quiet:, command_runner:, events:)
+          if local_path_development_env?(setup_env)
+            return {
+              name: "reset_release_lockfiles",
+              command: %w[kettle-reset release-lockfiles],
+              status: "skipped",
+              reason: "local_path_development_env"
+            }
+          end
+
+          reset_command_runner = lambda do |command|
+            command_runner.call(Shellwords.split(command), chdir: project_root, env: setup_env, quiet: quiet)
+          end
+          resetter = Kettle::Dev::LockfileReset.new(
+            root: project_root,
+            command_runner: reset_command_runner
+          )
+          paths = resetter.lockfile_paths
+          if paths.empty?
+            return {
+              name: "reset_release_lockfiles",
+              command: %w[kettle-reset release-lockfiles],
+              status: "skipped",
+              reason: "no_release_lockfiles"
+            }
+          end
+
+          Kettle::Jem.emit_step_event(
+            events,
+            "command_step",
+            {name: "reset_release_lockfiles", status: "started", command: %w[kettle-reset release-lockfiles]},
+            phase: "prepare"
+          )
+          before = snapshot_files(paths)
+          resetter.reset(Kettle::Dev::LockfileReset::RELEASE_LOCKFILES_TARGET)
+          changed_files = changed_files_since(project_root, before)
+          {
+            name: "reset_release_lockfiles",
+            command: %w[kettle-reset release-lockfiles],
+            status: "succeeded",
+            changed_files: changed_files,
+            quiet: quiet
+          }
+        end
+
+        def local_path_development_env?(env)
+          (env || {}).any? do |key, raw_value|
+            next false unless key.to_s.end_with?("_DEV")
+
+            value = raw_value.to_s.strip
+            !value.empty? && !Kettle::Jem::DecisionPolicy.falsey?(value)
+          end
+        end
+
+        def bundle_update_templating_bootstrap_command(project_root = Dir.pwd)
+          %w[bundle update] + CRITICAL_TEMPLATING_GEMS + locked_templating_gems(project_root)
+        end
+
+        def templating_bootstrap_command(project_root = Dir.pwd)
+          return %w[bundle install] unless templating_bootstrap_lockfile_ready?(project_root)
+
+          bundle_update_templating_bootstrap_command(project_root)
+        end
+
+        def templating_bootstrap_step_name(project_root = Dir.pwd)
+          return "bundle_install_templating_bootstrap" unless templating_bootstrap_lockfile_ready?(project_root)
+
+          "bundle_update_templating_bootstrap"
+        end
+
+        def templating_bootstrap_lockfile_ready?(project_root)
+          lock_path = File.join(project_root.to_s, "Gemfile.lock")
+          return false unless File.file?(lock_path)
+
+          locked_gem_names(project_root).then do |names|
+            CRITICAL_TEMPLATING_GEMS.all? { |gem_name| names.include?(gem_name) }
+          end
+        rescue Bundler::LockfileError
+          false
+        end
+
+        def bundle_install_after_bootstrap_step(project_root:, setup_env:, quiet:, command_runner:, events:, bootstrap_command:)
+          if bootstrap_command == %w[bundle install]
+            return {
+              name: "bundle_install",
+              command: %w[bundle install],
+              status: "skipped",
+              reason: "already_ran_as_templating_bootstrap"
+            }
+          end
+
+          Kettle::Jem.emit_step_event(
+            events,
+            "command_step",
+            {name: "bundle_install", status: "started", command: %w[bundle install]},
+            phase: "prepare"
+          )
+          Kettle::Jem::Tasks::InstallTask.run_command_step(
+            "bundle_install",
+            %w[bundle install],
+            project_root: project_root,
+            env: setup_env,
+            quiet: quiet,
+            command_runner: command_runner
+          )
+        end
+
+        def locked_templating_gems(project_root)
+          LOCKED_TEMPLATING_GEMS & locked_gem_names(project_root)
+        end
+
+        def locked_gem_names(project_root)
+          lock_path = File.join(project_root.to_s, "Gemfile.lock")
+          return [] unless File.file?(lock_path)
+
+          Bundler::LockfileParser.new(Bundler.read_file(lock_path)).specs.map(&:name)
+        end
+
+        def snapshot_files(paths)
+          paths.each_with_object({}) do |path, snapshot|
+            snapshot[path] = File.file?(path) ? File.binread(path) : nil
+          end
+        end
+
+        def changed_files_since(project_root, snapshot)
+          snapshot.filter_map do |path, before|
+            after = File.file?(path) ? File.binread(path) : nil
+            next if before == after
+
+            Pathname.new(path).relative_path_from(Pathname.new(project_root)).to_s
+          end.sort
+        end
+      end
+    end
+  end
+end

data/lib/kettle/jem/tasks/self_test_task.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+
+module Kettle
+  module Jem
+    module Tasks
+      module SelfTestTask
+        SKIPPED_PREFIXES = %w[
+          examples/
+          exe/
+          lib/
+          sig/
+          spec/
+          template/
+        ].freeze
+        SKIPPED_FILES = %w[
+          .kettle-jem.yml
+          .rubocop_gradual.lock
+          Gemfile.lock
+        ].freeze
+        GENERATED_RUNTIME_PREFIXES = %w[
+          tmp/kettle-jem/templating-report-
+        ].freeze
+        SELFTEST_IGNORED_FILES = %w[
+          gemfiles/modular/shunted.gemfile
+          results/test_results.html
+          tmp/.gitignore
+        ].freeze
+
+        module_function
+
+        def run(project_root: Dir.pwd, destination_root: project_root, template_root: nil, output_root: nil, min_divergence_threshold: nil)
+          root = File.expand_path(destination_root)
+          base_dir = output_root || File.join(root, "tmp", "template_test")
+          before_dir = File.join(base_dir, "destination")
+          after_dir = File.join(base_dir, "output")
+          report_dir = File.join(base_dir, "report")
+          diffs_dir = File.join(report_dir, "diffs")
+
+          FileUtils.rm_rf(base_dir)
+          [before_dir, after_dir, report_dir, diffs_dir].each { |path| FileUtils.mkdir_p(path) }
+          copy_tree(root, before_dir)
+          copy_tree(root, after_dir)
+
+          before = Kettle::Jem::SelfTest::Manifest.generate(before_dir)
+          File.write(File.join(report_dir, "before.json"), "#{JSON.pretty_generate(before)}\n")
+
+          write_template_root_override(after_dir, template_root) if template_root
+          Kettle::Jem.apply_project(after_dir, env: ENV, run_options: {accept: true, force: true, skip_commit: true})
+
+          after = Kettle::Jem::SelfTest::Manifest.generate(after_dir)
+          File.write(File.join(report_dir, "after.json"), "#{JSON.pretty_generate(after)}\n")
+
+          comparison = classify_comparison(Kettle::Jem::SelfTest::Manifest.compare(before, after))
+          diff_count = write_diffs(comparison, before_dir: before_dir, after_dir: after_dir, diffs_dir: diffs_dir)
+          drift = drift_report(after_dir: after_dir, template_root: template_root || Kettle::Jem.template_root_path(after_dir))
+          summary = Kettle::Jem::SelfTest::Reporter.summary(
+            comparison,
+            output_dir: after_dir,
+            templating_environment: Kettle::Jem::TemplatingReport.snapshot,
+            diff_count: diff_count
+          )
+          summary = append_drift_summary(summary, drift)
+          summary_path = File.join(report_dir, "summary.md")
+          File.write(summary_path, summary)
+          score, divergence = score_and_divergence(comparison)
+          threshold = selftest_threshold(min_divergence_threshold, root)
+
+          result = {
+            mode: "selftest",
+            destination_root: root,
+            template_root: template_root || Kettle::Jem.template_root_path(root),
+            output_root: after_dir,
+            report_path: summary_path,
+            comparison: comparison,
+            score: score,
+            divergence: divergence,
+            min_divergence_threshold: threshold,
+            drift: drift
+          }
+          if threshold && divergence > threshold
+            raise Kettle::Jem::Error, "selftest divergence #{divergence}% exceeds threshold #{threshold}%"
+          end
+          result
+        end
+
+        def copy_tree(source, destination)
+          Find.find(source) do |path|
+            relative = path.sub(%r{\A#{Regexp.escape(source)}/?}, "")
+            next if relative.empty?
+            next Find.prune if ignored_tree_entry?(relative, path)
+
+            target = File.join(destination, relative)
+            if File.directory?(path)
+              FileUtils.mkdir_p(target)
+            else
+              FileUtils.mkdir_p(File.dirname(target))
+              FileUtils.cp(path, target)
+            end
+          end
+        end
+
+        def ignored_tree_entry?(relative, path)
+          return false unless File.directory?(path)
+
+          %w[.git .yardoc coverage docs node_modules pkg tmp].include?(relative.split("/").first)
+        end
+
+        def write_diffs(comparison, before_dir:, after_dir:, diffs_dir:)
+          count = 0
+          comparison.fetch(:changed, []).each do |relative|
+            diff = Kettle::Jem::SelfTest::Reporter.diff(
+              File.join(before_dir, relative),
+              File.join(after_dir, relative)
+            )
+            next if diff.empty?
+
+            diff_path = File.join(diffs_dir, "#{relative}.diff")
+            FileUtils.mkdir_p(File.dirname(diff_path))
+            File.write(diff_path, diff)
+            count += 1
+          end
+          count
+        end
+
+        def classify_comparison(comparison)
+          changed = comparison.fetch(:changed, []).reject { |relative| ignored_selftest_artifact?(relative) }
+          added = comparison.fetch(:added, []).reject { |relative| ignored_selftest_artifact?(relative) }
+          skipped, removed = comparison.fetch(:removed, []).partition do |relative|
+            ignored_selftest_artifact?(relative) || expected_non_templated_path?(relative)
+          end
+          comparison.merge(changed: changed, added: added, removed: removed, skipped: skipped)
+        end
+
+        def expected_non_templated_path?(relative_path)
+          path_parts = relative_path.to_s.split("/")
+          SKIPPED_FILES.include?(relative_path) ||
+            SKIPPED_PREFIXES.any? { |prefix| relative_path.start_with?(prefix) } ||
+            (path_parts.length == 2 && path_parts.first == "gemfiles" && path_parts.last.end_with?(".gemfile")) ||
+            relative_path.to_s.end_with?(".gemspec")
+        end
+
+        def ignored_selftest_artifact?(relative_path)
+          generated_runtime_artifact?(relative_path) || SELFTEST_IGNORED_FILES.include?(relative_path)
+        end
+
+        def generated_runtime_artifact?(relative_path)
+          GENERATED_RUNTIME_PREFIXES.any? { |prefix| relative_path.start_with?(prefix.to_s) }
+        end
+
+        def score_and_divergence(comparison)
+          total = comparison.fetch(:matched, []).size +
+            comparison.fetch(:changed, []).size +
+            comparison.fetch(:added, []).size +
+            comparison.fetch(:removed, []).size
+          score = total.zero? ? 0.0 : (comparison.fetch(:matched, []).size.to_f / total * 100).round(1)
+          [score, (100.0 - score).round(1)]
+        end
+
+        def selftest_threshold(explicit, root)
+          return explicit.to_f if explicit
+
+          env_threshold = ENV["KJ_MIN_DIVERGENCE_THRESHOLD"].to_s.strip
+          return env_threshold.to_f unless env_threshold.empty?
+
+          config_path = File.join(root, ".kettle-jem.yml")
+          return unless File.file?(config_path)
+
+          config = YAML.load_file(config_path)
+          value = config["min_divergence_threshold"] if config.is_a?(Hash)
+          return if value.nil? || value.to_s.strip.empty?
+
+          Float(value)
+        rescue ArgumentError, TypeError
+          raise Kettle::Jem::Error, "Invalid selftest min_divergence_threshold"
+        end
+
+        def write_template_root_override(root, template_root)
+          config_path = File.join(root, ".kettle-jem.yml")
+          content = File.file?(config_path) ? File.read(config_path) : ""
+          File.write(config_path, upsert_template_root_override(content, File.expand_path(template_root)))
+        end
+
+        def upsert_template_root_override(content, template_root)
+          # This is line-oriented instead of YAML round-tripping because the self-test fixture config must preserve
+          # comments, key order, and scalar spellings while injecting a temporary local template root.
+          lines = content.to_s.lines
+          template_index = lines.index { |line| line.match?(/\Atemplates:\s*(?:#.*)?\n?\z/) }
+          if template_index
+            root_index = ((template_index + 1)...lines.length).find do |index|
+              line = lines[index]
+              break nil unless line.strip.empty? || line.start_with?(" ")
+
+              line.match?(/\A\s+root\s*:/)
+            end
+            if root_index
+              lines[root_index] = "  root: #{template_root}\n"
+            else
+              lines.insert(template_index + 1, "  root: #{template_root}\n")
+            end
+          else
+            lines << "\n" unless lines.empty? || lines.last.to_s.strip.empty?
+            lines << "templates:\n"
+            lines << "  root: #{template_root}\n"
+          end
+          output = lines.join
+          output.end_with?("\n") ? output : "#{output}\n"
+        end
+
+        def drift_report(after_dir:, template_root:)
+          unless defined?(Kettle::Drift)
+            return {
+              available: false,
+              reason: "kettle-drift is not available"
+            }
+          end
+
+          outcome = Kettle::Drift.run(
+            project_root: after_dir,
+            template_dir: template_root,
+            lock_path: File.join("tmp", "template_test", ".kettle-drift.lock"),
+            mode: :force_update,
+            printer_class: nil
+          )
+          {
+            available: true,
+            warning_count: outcome.warning_count,
+            json_path: outcome.json_path,
+            lock_path: outcome.lock_path,
+            exit_code: outcome.exit_code
+          }
+        rescue => error
+          {
+            available: false,
+            reason: "#{error.class}: #{error.message}"
+          }
+        end
+
+        def append_drift_summary(summary, drift)
+          return summary unless drift
+
+          lines = [summary, "", "## Drift Analysis", ""]
+          if drift[:available]
+            lines << "**Duplicate drift warnings**: #{drift.fetch(:warning_count)}"
+            lines << "**Drift report**: `#{drift[:json_path]}`" if drift[:json_path]
+          else
+            lines << "Drift analysis unavailable: #{drift[:reason]}"
+          end
+          lines << ""
+          lines.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/kettle/jem/tasks/template_task.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "etc"
+
+module Kettle
+  module Jem
+    module Tasks
+      module TemplateTask
+        module_function
+
+        def run(project_root: Dir.pwd, env: ENV, run_options: nil, command_runner: Kettle::Jem::Tasks::InstallTask.method(:run_system_command))
+          effective_run_options = templating_run_options(env, run_options)
+          report = if Dir.glob(File.join(project_root.to_s, "*.gemspec")).empty? && !monorepo_root_profile?(project_root, env, effective_run_options)
+            {
+              mode: "apply",
+              changed_files: [],
+              diagnostics: [],
+              recipe_reports: []
+            }
+          else
+            Kettle::Jem.apply_project(project_root, env: env, run_options: effective_run_options)
+          end
+          setup_env = Kettle::Jem::Tasks::InstallTask.setup_command_env(project_root, env)
+          hook_step = Kettle::Jem::Tasks::InstallTask.hook_templates_step(project_root, effective_run_options)
+          git_drivers_step = Kettle::Jem::Tasks::InstallTask.git_drivers_step(project_root, effective_run_options)
+          lock_step = Kettle::Jem::Tasks::InstallTask.normalize_lockfile_step(project_root, env: setup_env, run_options: effective_run_options)
+          template_steps = Kettle::Jem::Tasks::InstallTask.execute_orchestration_steps(
+            [hook_step, git_drivers_step, lock_step],
+            project_root: project_root,
+            env: setup_env,
+            run_options: effective_run_options,
+            command_runner: command_runner,
+            event_phase: "template"
+          )
+          final_report = report.merge(mode: "template", template_steps: template_steps)
+          Kettle::Jem.emit_summary_event(Kettle::Jem.event_stream_from_options(effective_run_options), final_report)
+          final_report
+        end
+
+        def templating_run_options(env, run_options)
+          options = env_run_options(env || {}).merge(run_options || {})
+          return options if worker_or_strategy_option_provided?(env || {}, options)
+
+          workers = default_thread_worker_count
+          options.merge(
+            recipe_planning_strategy: "classified",
+            recipe_planning_thread_workers: workers,
+            file_work_thread_workers: workers
+          )
+        end
+
+        def env_run_options(env)
+          {
+            accept: truthy?(env["accept"]) || truthy?(env["force"]),
+            force: truthy?(env["force"]),
+            interactive: falsey?(env["force"]),
+            failure_mode: env["FAILURE_MODE"] || env["failure_mode"],
+            allowed: env["allowed"],
+            hook_templates: env["hook_templates"],
+            git_drivers: env["git_drivers"] || env["KETTLE_JEM_GIT_DRIVERS"],
+            only: env["only"],
+            include: env["include"],
+            template_profile: env["KETTLE_JEM_TEMPLATE_PROFILE"],
+            dry_run: truthy?(env["KETTLE_JEM_DRY_RUN"]),
+            skip_commit: truthy?(env["KETTLE_JEM_SKIP_COMMIT"]),
+            skip_drift_check: truthy?(env["KETTLE_JEM_SKIP_DRIFT_CHECK"]),
+            skip_rubocop_gradual: truthy?(env["KETTLE_JEM_SKIP_RUBOCOP_GRADUAL"]),
+            skip_binstubs: truthy?(env["KETTLE_JEM_SKIP_BINSTUBS"]),
+            skip_appraisal_generate: truthy?(env["KETTLE_JEM_SKIP_APPRAISAL_GENERATE"]),
+            skip_lock_normalization: truthy?(env["KETTLE_JEM_SKIP_LOCK_NORMALIZATION"]),
+            checksums: env["KETTLE_JEM_CHECKSUMS"],
+            accept_config: truthy?(env["KETTLE_JEM_ACCEPT_CONFIG"]),
+            bootstrap_mode: truthy?(env["KETTLE_JEM_BOOTSTRAP_MODE"]),
+            quiet: truthy?(env["KETTLE_JEM_QUIET"]),
+            verbose: truthy?(env["KETTLE_JEM_VERBOSE"])
+          }.compact
+        end
+
+        def default_thread_worker_count
+          [1, Etc.nprocessors / 2].max
+        end
+
+        def worker_or_strategy_option_provided?(env, run_options)
+          option_keys = %i[
+            ractor_workers
+            recipe_planning_workers
+            thread_workers
+            recipe_planning_thread_workers
+            ractor_file_workers
+            file_work_workers
+            thread_file_workers
+            file_work_thread_workers
+            recipe_planning_strategy
+          ]
+          string_option_keys = option_keys.map(&:to_s)
+          env_keys = %w[
+            KETTLE_JEM_RACTOR_WORKERS
+            KETTLE_JEM_THREAD_WORKERS
+            KETTLE_JEM_RACTOR_FILE_WORKERS
+            KETTLE_JEM_THREAD_FILE_WORKERS
+            KETTLE_JEM_RECIPE_PLANNING_STRATEGY
+          ]
+          option_keys.any? { |key| run_options.key?(key) } ||
+            string_option_keys.any? { |key| run_options.key?(key) } ||
+            env_keys.any? { |key| env.key?(key) && !env[key].to_s.strip.empty? }
+        end
+
+        def truthy?(value)
+          Kettle::Jem::DecisionPolicy.truthy?(value)
+        end
+
+        def falsey?(value)
+          Kettle::Jem::DecisionPolicy.falsey?(value)
+        end
+
+        def monorepo_root_profile?(project_root, env, run_options)
+          profile = (run_options || {})[:template_profile] || (run_options || {})["template_profile"] || (env || {})["KETTLE_JEM_TEMPLATE_PROFILE"]
+          profile = Kettle::Jem.kettle_jem_config(project_root).dig("templates", "profile") if profile.to_s.empty?
+          Kettle::Jem.normalize_template_profile(profile) == Kettle::Jem::MONOREPO_ROOT_TEMPLATE_PROFILE
+        end
+      end
+    end
+  end
+end

data/lib/kettle/jem/tasks.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "rake"
+
+rakelib = File.expand_path("rakelib", __dir__)
+Dir[File.join(rakelib, "*.rake")].sort.each { |path| load path }

data/lib/kettle/jem/templates/.aiignore.example

@@ -0,0 +1,19 @@
+# An .aiignore file follows the same syntax as a .gitignore file.
+# .gitignore documentation: https://git-scm.com/docs/gitignore
+
+# you can ignore files
+.DS_Store
+*.log
+*.tmp
+
+# or folders
+.devcontainer/
+.qlty/
+.yardoc/
+dist/
+build/
+out/
+coverage/
+docs/
+pkg/
+results/