kompo 0.2.0 → 0.3.0

data/lib/kompo/tasks/build_native_gem.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "open3"
+
+module Kompo
+  # Build native gem extensions (C extensions and Rust extensions)
+  # Exports:
+  #   - exts: Array of [so_path, init_func] pairs for main.c template
+  #   - exts_dir: Directory containing compiled .o files
+  class BuildNativeGem < Taski::Task
+    exports :exts, :exts_dir
+
+    def run
+      @exts = []
+      @exts_dir = nil
+
+      extensions = FindNativeExtensions.extensions
+      if extensions.empty?
+        puts "No native extensions to build"
+        return
+      end
+
+      work_dir = WorkDir.path
+      @exts_dir = File.join(work_dir, "ext")
+
+      extensions.each do |ext|
+        build_extension(ext, work_dir)
+      end
+
+      puts "Completed #{@exts.size} native extensions"
+    end
+
+    def clean
+      return unless @exts_dir && Dir.exist?(@exts_dir)
+
+      FileUtils.rm_rf(@exts_dir)
+      puts "Cleaned up native extensions"
+    end
+
+    private
+
+    def build_extension(ext, work_dir)
+      dir_name = ext[:dir_name]
+      gem_ext_name = ext[:gem_ext_name]
+      ext_type = ext[:is_rust] ? "Rust" : "C"
+
+      group("Building #{gem_ext_name} (#{ext_type})") do
+        if ext[:is_rust]
+          build_rust_extension(dir_name, ext[:cargo_toml], gem_ext_name, work_dir)
+        else
+          build_c_extension(dir_name, gem_ext_name, work_dir)
+        end
+
+        register_extension(dir_name, gem_ext_name)
+        puts "Built: #{gem_ext_name}"
+      end
+    end
+
+    def register_extension(dir_name, gem_ext_name)
+      makefile_path = File.join(dir_name, "Makefile")
+
+      if File.exist?(makefile_path)
+        # C extension: parse Makefile
+        makefile_content = File.read(makefile_path)
+        prefix = makefile_content.scan(/target_prefix = (.*)/).flatten.first&.delete_prefix("/") || ""
+        target_name = makefile_content.scan(/TARGET_NAME = (.*)/).flatten.first || gem_ext_name
+      else
+        # Rust extension: parse Cargo.toml
+        cargo_toml_path = File.join(dir_name, "Cargo.toml")
+        unless File.exist?(cargo_toml_path)
+          raise "Cannot register extension #{gem_ext_name} in #{dir_name}: " \
+                "neither Makefile nor Cargo.toml found (build_rust_extension may have produced .a files)"
+        end
+
+        cargo_content = File.read(cargo_toml_path)
+        prefix = "" # Rust extensions typically don't have a prefix
+        target_name = parse_cargo_toml_target_name(cargo_content)
+        unless target_name
+          raise "Cannot determine target name for #{gem_ext_name} in #{dir_name}: " \
+                "Cargo.toml lacks [lib].name or [package].name"
+        end
+      end
+
+      # Path for ruby_init_ext must match require path (without file extension)
+      ext_path = File.join(prefix, target_name).delete_prefix("/")
+      @exts << [ext_path, "Init_#{target_name}"]
+    end
+
+    # Parse Cargo.toml to extract target name
+    # Prefers [lib].name over [package].name
+    def parse_cargo_toml_target_name(content)
+      current_section = nil
+      lib_name = nil
+      package_name = nil
+
+      content.each_line do |line|
+        line = line.strip
+
+        # Match section headers like [package], [lib], etc.
+        if line =~ /^\[([^\]]+)\]$/
+          current_section = ::Regexp.last_match(1)
+          next
+        end
+
+        # Match name = "value" or name = 'value'
+        if line =~ /^name\s*=\s*["']([^"']+)["']$/
+          case current_section
+          when "lib"
+            lib_name = ::Regexp.last_match(1)
+          when "package"
+            package_name = ::Regexp.last_match(1)
+          end
+        end
+      end
+
+      # Prefer [lib].name over [package].name
+      lib_name || package_name
+    end
+
+    def build_rust_extension(dir_name, cargo_toml, gem_ext_name, work_dir)
+      cargo = CargoPath.path
+
+      puts "Building Rust extension: #{gem_ext_name}"
+      # Use absolute path for --target-dir to ensure artifacts are placed correctly
+      target_dir = File.join(dir_name, "target")
+      command = [
+        cargo,
+        "rustc",
+        "--release",
+        "--crate-type=staticlib",
+        "--target-dir", target_dir,
+        "--manifest-path", cargo_toml
+      ]
+
+      system(*command) or raise "Failed to build Rust extension: #{gem_ext_name}"
+
+      # Copy .a files to ext directory
+      copy_targets = Dir.glob(File.join(target_dir, "release/*.a"))
+      dest_dir = FileUtils.mkdir_p(File.join(work_dir, "ext", gem_ext_name)).first
+      FileUtils.cp(copy_targets, dest_dir)
+    end
+
+    def build_c_extension(dir_name, gem_ext_name, work_dir)
+      puts "Building C extension: #{gem_ext_name}"
+
+      # Run extconf.rb to generate Makefile
+      # Use system Ruby so build-time dependencies (e.g., mini_portile2) are available via Bundler
+      puts "Running extconf.rb in #{dir_name}"
+      extconf_output, status = Open3.capture2e("ruby", "extconf.rb", chdir: dir_name)
+      unless status.success?
+        warn "extconf.rb failed for #{gem_ext_name}"
+        warn "extconf.rb output:\n#{extconf_output}"
+        raise "Failed to run extconf.rb for #{gem_ext_name}"
+      end
+
+      # Extract OBJS from Makefile and build
+      makefile_path = File.join(dir_name, "Makefile")
+      makefile_content = File.read(makefile_path)
+      objs_match = makefile_content.match(/OBJS = (.*\.o)/)
+      return unless objs_match
+
+      # Get full extension path (prefix/target_name) for proper directory structure
+      # This ensures erb/escape and cgi/escape are stored in different directories
+      prefix = makefile_content.scan(/target_prefix = (.*)/).flatten.first&.delete_prefix("/") || ""
+      target_name = makefile_content.scan(/TARGET_NAME = (.*)/).flatten.first || gem_ext_name
+      ext_path = File.join(prefix, target_name).delete_prefix("/")
+      dest_ext_dir = File.join(work_dir, "ext", ext_path)
+
+      # Skip if already built
+      return if Dir.exist?(dest_ext_dir)
+
+      objs = objs_match[1]
+      puts "Building objects: #{objs}"
+      # Use Open3.capture2e with array form to avoid shell injection
+      make_args = ["make", "-C", dir_name] + objs.split + ["--always-make"]
+      make_output, status = Open3.capture2e(*make_args)
+      unless status.success?
+        warn "make failed for #{gem_ext_name} in #{dir_name}"
+        warn "Make output:\n#{make_output}"
+        warn "Makefile content:\n#{makefile_content[0..500]}"
+        raise "Failed to make #{gem_ext_name}"
+      end
+
+      # Copy .o files to ext directory
+      copy_targets = objs.split.map { |o| File.join(dir_name, o) }
+      dest_dir = FileUtils.mkdir_p(dest_ext_dir).first
+      FileUtils.cp(copy_targets, dest_dir)
+    end
+  end
+end

data/lib/kompo/tasks/bundle_install.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'digest'
+require 'json'
+require 'bundler'
+
+module Kompo
+  # Shared helpers for bundle cache operations
+  module BundleCacheHelpers
+    private
+
+    def compute_bundle_cache_name
+      hash = compute_gemfile_lock_hash
+      return nil unless hash
+
+      "bundle-#{hash}"
+    end
+
+    def compute_gemfile_lock_hash
+      work_dir = WorkDir.path
+      gemfile_lock_path = File.join(work_dir, 'Gemfile.lock')
+      return nil unless File.exist?(gemfile_lock_path)
+
+      content = File.read(gemfile_lock_path)
+      Digest::SHA256.hexdigest(content)[0..15]
+    end
+  end
+
+  # Run bundle install --path bundle in work directory
+  # Uses standard Bundler (not standalone mode) so Bundler.require works
+  # Supports caching based on Gemfile.lock hash and Ruby version
+  class BundleInstall < Taski::Section
+    include BundleCacheHelpers
+
+    interfaces :bundle_ruby_dir, :bundler_config_path
+
+    def impl
+      # Skip if no Gemfile
+      return Skip unless CopyGemfile.gemfile_exists
+
+      # Skip cache if --no-cache is specified
+      return FromSource if Taski.args[:no_cache]
+
+      cache_exists? ? FromCache : FromSource
+    end
+
+    # Restore bundle from cache
+    class FromCache < Taski::Task
+      include BundleCacheHelpers
+
+      def run
+        work_dir = WorkDir.path
+        ruby_major_minor = InstallRuby.ruby_major_minor
+
+        @bundle_ruby_dir = File.join(work_dir, 'bundle', 'ruby', "#{ruby_major_minor}.0")
+        @bundler_config_path = File.join(work_dir, '.bundle', 'config')
+
+        kompo_cache = Taski.args.fetch(:kompo_cache, File.expand_path('~/.kompo/cache'))
+        ruby_version = InstallRuby.ruby_version
+        version_cache_dir = File.join(kompo_cache, ruby_version)
+
+        bundle_cache_name = compute_bundle_cache_name
+        raise "Gemfile.lock not found in #{work_dir}" unless bundle_cache_name
+
+        cache_dir = File.join(version_cache_dir, bundle_cache_name)
+
+        group('Restoring bundle from cache') do
+          # Clean up existing files in case work_dir is reused
+          FileUtils.rm_rf(File.join(work_dir, 'bundle')) if Dir.exist?(File.join(work_dir, 'bundle'))
+          FileUtils.rm_rf(File.join(work_dir, '.bundle')) if Dir.exist?(File.join(work_dir, '.bundle'))
+
+          # Copy from cache
+          FileUtils.cp_r(File.join(cache_dir, 'bundle'), File.join(work_dir, 'bundle'))
+          FileUtils.cp_r(File.join(cache_dir, '.bundle'), File.join(work_dir, '.bundle'))
+
+          puts "Restored from: #{cache_dir}"
+        end
+
+        puts 'Bundle restored from cache'
+      end
+
+      def clean
+        work_dir = WorkDir.path
+        return unless work_dir && Dir.exist?(work_dir)
+
+        [@bundle_ruby_dir, @bundler_config_path].each do |path|
+          next unless path
+
+          FileUtils.rm_rf(path) if File.exist?(path)
+        end
+        puts 'Cleaned up bundle installation'
+      end
+    end
+
+    # Run bundle install and save to cache
+    class FromSource < Taski::Task
+      include BundleCacheHelpers
+
+      def run
+        work_dir = WorkDir.path
+        bundler = InstallRuby.bundler_path
+        ruby_major_minor = InstallRuby.ruby_major_minor
+
+        @bundle_ruby_dir = File.join(work_dir, 'bundle', 'ruby', "#{ruby_major_minor}.0")
+        @bundler_config_path = File.join(work_dir, '.bundle', 'config')
+
+        puts 'Running bundle install --path bundle...'
+        gemfile_path = File.join(work_dir, 'Gemfile')
+
+        # Clear Bundler environment and specify Gemfile path explicitly
+        Bundler.with_unbundled_env do
+          ruby = InstallRuby.ruby_path
+          env = { 'BUNDLE_GEMFILE' => gemfile_path }
+
+          # Suppress clang 18+ warning that causes mkmf try_cppflags to fail
+          # This flag is clang-specific and not recognized by GCC
+          if clang_compiler?
+            env['CFLAGS'] = '-Wno-default-const-init-field-unsafe'
+            env['CPPFLAGS'] = '-Wno-default-const-init-field-unsafe'
+          end
+
+          # Set BUNDLE_PATH to "bundle" - standard Bundler reads .bundle/config
+          # and finds gems in {BUNDLE_PATH}/ruby/X.X.X/gems/
+          # Use ruby to execute bundler to avoid shebang issues
+          system({ 'BUNDLE_GEMFILE' => gemfile_path }, ruby, bundler, 'config', 'set', '--local', 'path',
+                 'bundle') or raise 'Failed to set bundle path'
+          system(env, ruby, bundler, 'install') or raise 'Failed to run bundle install'
+        end
+
+        puts 'Bundle installed successfully'
+
+        # Save to cache
+        save_to_cache(work_dir)
+      end
+
+      def clean
+        work_dir = WorkDir.path
+        return unless work_dir && Dir.exist?(work_dir)
+
+        [@bundle_ruby_dir, @bundler_config_path].each do |path|
+          next unless path
+
+          FileUtils.rm_rf(path) if File.exist?(path)
+        end
+        puts 'Cleaned up bundle installation'
+      end
+
+      private
+
+      def clang_compiler?
+        output = `cc --version 2>&1`
+        output.include?('clang')
+      rescue Errno::ENOENT => e
+        warn "cc command not found: #{e.message}"
+        false
+      rescue StandardError => e
+        warn "Error checking compiler: #{e.message}"
+        false
+      end
+
+      def save_to_cache(work_dir)
+        bundle_cache_name = compute_bundle_cache_name
+        return unless bundle_cache_name
+
+        kompo_cache = Taski.args.fetch(:kompo_cache, File.expand_path('~/.kompo/cache'))
+        ruby_version = InstallRuby.ruby_version
+        version_cache_dir = File.join(kompo_cache, ruby_version)
+        cache_dir = File.join(version_cache_dir, bundle_cache_name)
+
+        group('Saving bundle to cache') do
+          # Remove old cache if exists
+          FileUtils.rm_rf(cache_dir) if Dir.exist?(cache_dir)
+          FileUtils.mkdir_p(cache_dir)
+
+          # Copy to cache
+          FileUtils.cp_r(File.join(work_dir, 'bundle'), File.join(cache_dir, 'bundle'))
+          FileUtils.cp_r(File.join(work_dir, '.bundle'), File.join(cache_dir, '.bundle'))
+
+          # Save metadata
+          metadata = {
+            'ruby_version' => ruby_version,
+            'gemfile_lock_hash' => compute_gemfile_lock_hash,
+            'created_at' => Time.now.iso8601
+          }
+          File.write(File.join(cache_dir, 'metadata.json'), JSON.pretty_generate(metadata))
+
+          puts "Saved to: #{cache_dir}"
+        end
+      end
+    end
+
+    # Skip bundle install when no Gemfile
+    class Skip < Taski::Task
+      def run
+        puts 'No Gemfile, skipping bundle install'
+        @bundle_ruby_dir = nil
+        @bundler_config_path = nil
+      end
+
+      def clean
+        # Nothing to clean
+      end
+    end
+
+    private
+
+    def cache_exists?
+      bundle_cache_name = compute_bundle_cache_name
+      return false unless bundle_cache_name
+
+      kompo_cache = Taski.args.fetch(:kompo_cache, File.expand_path('~/.kompo/cache'))
+      ruby_version = InstallRuby.ruby_version
+      version_cache_dir = File.join(kompo_cache, ruby_version)
+      cache_dir = File.join(version_cache_dir, bundle_cache_name)
+
+      cache_bundle_dir = File.join(cache_dir, 'bundle')
+      cache_bundle_config = File.join(cache_dir, '.bundle')
+      cache_metadata = File.join(cache_dir, 'metadata.json')
+
+      Dir.exist?(cache_bundle_dir) && Dir.exist?(cache_bundle_config) && File.exist?(cache_metadata)
+    end
+  end
+end

data/lib/kompo/tasks/cargo_path.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module Kompo
+  # Section to get the Cargo path.
+  # Switches implementation based on whether Cargo is already installed.
+  class CargoPath < Taski::Section
+    interfaces :path
+
+    def impl
+      cargo_installed? ? Installed : Install
+    end
+
+    # Use existing Cargo installation
+    class Installed < Taski::Task
+      def run
+        # First check PATH, then fallback to default rustup location
+        cargo_in_path, = Open3.capture2('which', 'cargo', err: File::NULL)
+        cargo_in_path = cargo_in_path.chomp
+        @path = if cargo_in_path.empty?
+                  File.expand_path('~/.cargo/bin/cargo')
+                else
+                  cargo_in_path
+                end
+        puts "Cargo path: #{@path}"
+        version_output, = Open3.capture2e(@path, '--version')
+        puts "Cargo version: #{version_output.chomp}"
+      end
+    end
+
+    # Install Cargo via rustup and return the path
+    class Install < Taski::Task
+      def run
+        puts 'Cargo not found. Installing via rustup...'
+        system("curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y")
+
+        @path = File.expand_path('~/.cargo/bin/cargo')
+        raise 'Failed to install Cargo' unless File.executable?(@path)
+
+        puts "Cargo installed at: #{@path}"
+        version_output, = Open3.capture2e(@path, '--version')
+        puts "Cargo version: #{version_output.chomp}"
+      end
+    end
+
+    private
+
+    def cargo_installed?
+      # Check if cargo is in PATH
+      cargo_in_path, = Open3.capture2('which', 'cargo', err: File::NULL)
+      return true unless cargo_in_path.chomp.empty?
+
+      # Check default rustup installation location
+      home_cargo = File.expand_path('~/.cargo/bin/cargo')
+      File.executable?(home_cargo)
+    end
+  end
+end

data/lib/kompo/tasks/check_stdlibs.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module Kompo
+  # Get Ruby standard library paths from installed Ruby
+  class CheckStdlibs < Taski::Task
+    exports :paths
+
+    def run
+      # Check if stdlib should be excluded
+      no_stdlib = Taski.args.fetch(:no_stdlib, false)
+      if no_stdlib
+        @paths = []
+        puts 'Skipping standard library (--no-stdlib)'
+        return
+      end
+
+      ruby = InstallRuby.ruby_path
+      ruby_install_dir = InstallRuby.ruby_install_dir
+      original_ruby_install_dir = InstallRuby.original_ruby_install_dir
+      ruby_major_minor = InstallRuby.ruby_major_minor
+
+      # Include the Ruby standard library root directory
+      # This includes bundler and other default gems that are not in $:
+      # Ruby uses "X.Y.0" format for lib/ruby paths (e.g., "3.4.0" not "3.4")
+      stdlib_root = File.join(ruby_install_dir, 'lib', 'ruby', "#{ruby_major_minor}.0")
+      # RubyGems needs gemspec files in specifications/ directory
+      gems_specs_root = File.join(ruby_install_dir, 'lib', 'ruby', 'gems', "#{ruby_major_minor}.0", 'specifications')
+
+      if Dir.exist?(stdlib_root)
+        @paths = [stdlib_root, gems_specs_root].select { |p| Dir.exist?(p) }
+        puts "Including Ruby standard library: #{stdlib_root}"
+        puts "Including gem specifications: #{gems_specs_root}" if Dir.exist?(gems_specs_root)
+      else
+        # Fallback to $: paths if stdlib root doesn't exist
+        output, status = Open3.capture2(ruby, '-e', 'puts $:', err: File::NULL)
+        unless status.success?
+          raise "Failed to get Ruby standard library paths: exit code #{status.exitstatus}, output: #{output}"
+        end
+
+        raw_paths = output.split("\n").reject(&:empty?)
+
+        @paths = raw_paths.map do |path|
+          next nil unless path.start_with?('/')
+
+          if original_ruby_install_dir != ruby_install_dir && path.start_with?(original_ruby_install_dir)
+            path.sub(original_ruby_install_dir, ruby_install_dir)
+          else
+            path
+          end
+        end.compact
+
+        puts "Found #{@paths.size} standard library paths (fallback)"
+      end
+    end
+  end
+end

data/lib/kompo/tasks/collect_dependencies.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Kompo
+  # Collect all dependencies for packing.
+  # This task is used by Packing to get the values it needs.
+  class CollectDependencies < Taski::Task
+    exports :work_dir, :deps, :ext_paths, :enc_files, :output_path
+
+    Dependencies = Struct.new(
+      :ruby_install_dir, :ruby_version, :ruby_major_minor,
+      :ruby_build_path, :ruby_lib, :kompo_lib,
+      :main_c, :fs_c, :exts_dir, :deps_lib_paths,
+      keyword_init: true
+    )
+
+    def run
+      @work_dir = WorkDir.path
+      project_dir = Taski.args.fetch(:project_dir, Taski.env.working_directory) || Taski.env.working_directory
+      output_arg = Taski.args.fetch(:output_dir, Taski.env.working_directory) || Taski.env.working_directory
+
+      @deps = group('Collecting dependencies') do
+        collect_dependencies
+      end
+
+      # If output_arg is an existing directory, create binary inside it
+      # Otherwise, treat it as the output file path
+      if File.directory?(output_arg)
+        @output_path = File.join(output_arg, File.basename(project_dir))
+      else
+        @output_path = output_arg
+        # Ensure parent directory exists
+        FileUtils.mkdir_p(File.dirname(@output_path))
+      end
+
+      @ext_paths = get_unique_ext_paths(@work_dir, @deps.ruby_build_path, @deps.ruby_version, @deps.exts_dir)
+      @enc_files = [
+        File.join(@deps.ruby_build_path, "ruby-#{@deps.ruby_version}", 'enc/encinit.o'),
+        File.join(@deps.ruby_build_path, "ruby-#{@deps.ruby_version}", 'enc/libenc.a'),
+        File.join(@deps.ruby_build_path, "ruby-#{@deps.ruby_version}", 'enc/libtrans.a')
+      ]
+
+      puts 'All dependencies collected for packing'
+    end
+
+    private
+
+    def collect_dependencies
+      # Install dependencies based on platform (Homebrew on macOS, pkg-config check on Linux)
+      InstallDeps.run
+      deps_lib_paths = InstallDeps.lib_paths
+
+      ruby_install_dir = InstallRuby.ruby_install_dir
+      ruby_version = InstallRuby.ruby_version
+      ruby_major_minor = InstallRuby.ruby_major_minor
+      ruby_build_path = InstallRuby.ruby_build_path
+      ruby_lib = File.join(ruby_install_dir, 'lib')
+
+      kompo_lib = KompoVfsPath.path
+      main_c = MakeMainC.path
+      fs_c = MakeFsC.path
+      exts_dir = BuildNativeGem.exts_dir
+
+      puts 'Dependencies collected'
+
+      Dependencies.new(
+        ruby_install_dir: ruby_install_dir,
+        ruby_version: ruby_version,
+        ruby_major_minor: ruby_major_minor,
+        ruby_build_path: ruby_build_path,
+        ruby_lib: ruby_lib,
+        kompo_lib: kompo_lib,
+        main_c: main_c,
+        fs_c: fs_c,
+        exts_dir: exts_dir,
+        deps_lib_paths: deps_lib_paths
+      )
+    end
+
+    def get_unique_ext_paths(_work_dir, ruby_build_path, ruby_version, exts_dir)
+      # Ruby standard extension .o files
+      paths = Dir.glob(File.join(ruby_build_path, "ruby-#{ruby_version}", 'ext', '**', '*.o'))
+
+      # Extract extension path (everything after /ext/) for deduplication
+      # e.g., ".../ext/cgi/escape/escape.o" -> "cgi/escape/escape.o"
+      ruby_ext_keys = paths.map { |p| p.split('/ext/').last }
+
+      # Gem extension .o files (excluding duplicates with Ruby std)
+      if exts_dir && Dir.exist?(exts_dir)
+        gem_ext_paths = Dir.glob("#{exts_dir}/**/*.o")
+                           .to_h { |p| [p.split('/ext/').last, p] }
+                           .except(*ruby_ext_keys)
+                           .values
+        paths += gem_ext_paths
+      end
+
+      paths
+    end
+  end
+end

data/lib/kompo/tasks/copy_gemfile.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Kompo
+  # Copy Gemfile and Gemfile.lock to working directory if they exist
+  class CopyGemfile < Taski::Task
+    exports :gemfile_exists
+
+    def run
+      work_dir = WorkDir.path
+      project_dir = Taski.args.fetch(:project_dir, Taski.env.working_directory) || Taski.env.working_directory
+
+      gemfile_path = File.join(project_dir, 'Gemfile')
+      gemfile_lock_path = File.join(project_dir, 'Gemfile.lock')
+
+      @gemfile_exists = File.exist?(gemfile_path)
+
+      if @gemfile_exists
+        FileUtils.cp(gemfile_path, work_dir)
+        puts 'Copied: Gemfile'
+
+        if File.exist?(gemfile_lock_path)
+          FileUtils.cp(gemfile_lock_path, work_dir)
+          puts 'Copied: Gemfile.lock'
+        end
+      else
+        puts 'No Gemfile found, skipping'
+      end
+    end
+
+    def clean
+      return unless @gemfile_exists
+
+      work_dir = WorkDir.path
+      return unless work_dir && Dir.exist?(work_dir)
+
+      gemfile = File.join(work_dir, 'Gemfile')
+      gemfile_lock = File.join(work_dir, 'Gemfile.lock')
+
+      FileUtils.rm_f(gemfile)
+      FileUtils.rm_f(gemfile_lock)
+      puts 'Cleaned up Gemfile'
+    end
+  end
+end