scint 0.1.0

data/lib/scint/cli/cache.rb

@@ -0,0 +1,316 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "../cache/layout"
+require_relative "../cache/prewarm"
+require_relative "../credentials"
+require_relative "../gemfile/dependency"
+require_relative "../gemfile/parser"
+require_relative "../lockfile/parser"
+require_relative "install"
+require_relative "../fs"
+
+module Scint
+  module CLI
+    class Cache
+      def initialize(argv = [])
+        @argv = argv.dup
+      end
+
+      def run
+        subcommand = @argv.shift || "help"
+
+        case subcommand
+        when "add"
+          add
+        when "clean", "clear"
+          clean
+        when "dir", "path"
+          dir
+        when "size"
+          size
+        when "help", "-h", "--help"
+          help
+          0
+        else
+          $stderr.puts "Unknown cache subcommand: #{subcommand}"
+          $stderr.puts "Run 'scint cache help' for usage."
+          1
+        end
+      end
+
+      private
+
+      def cache_root
+        @cache_root ||= Scint::Cache::Layout.new.root
+      end
+
+      # scint cache clean [package...]
+      # With no args, clear everything. With args, clear only matching entries.
+      def clean
+        packages = @argv.dup
+
+        unless Dir.exist?(cache_root)
+          $stdout.puts "No cache to clear (#{cache_root} does not exist)"
+          return 0
+        end
+
+        if packages.empty?
+          removed = clear_all
+          $stdout.puts "Cleared #{removed} entries from #{cache_root}"
+        else
+          removed = clear_packages(packages)
+          $stdout.puts "Removed #{removed} entries matching: #{packages.join(", ")}"
+        end
+
+        0
+      end
+
+      # scint cache dir
+      def dir
+        $stdout.puts cache_root
+        0
+      end
+
+      # scint cache size
+      def size
+        unless Dir.exist?(cache_root)
+          $stdout.puts "0 B (cache is empty)"
+          return 0
+        end
+
+        total_bytes = 0
+        total_files = 0
+        subdirs = {}
+
+        Dir.children(cache_root).sort.each do |subdir|
+          subdir_path = File.join(cache_root, subdir)
+          next unless File.directory?(subdir_path)
+
+          bytes = 0
+          files = 0
+          Dir.glob("**/*", base: subdir_path).each do |rel|
+            full = File.join(subdir_path, rel)
+            next unless File.file?(full)
+            bytes += File.size(full)
+            files += 1
+          end
+
+          subdirs[subdir] = { bytes: bytes, files: files }
+          total_bytes += bytes
+          total_files += files
+        end
+
+        # Print breakdown with aligned columns
+        all_rows = subdirs.map { |name, info| [name, info[:bytes], info[:files]] }
+        all_rows << ["total", total_bytes, total_files]
+
+        nw = all_rows.map { |r| r[0].length }.max
+        sw = all_rows.map { |r| format_size(r[1]).length }.max
+        fw = all_rows.map { |r| "#{r[2]} files".length }.max
+
+        all_rows.each do |name, bytes, files|
+          $stdout.printf "  %-*s  %*s  %*s\n", nw, name, sw, format_size(bytes), fw, "#{files} files"
+        end
+
+        0
+      end
+
+      def help
+        $stdout.puts <<~HELP
+          Manage scint's cache
+
+          Usage: scint cache <COMMAND>
+
+          Commands:
+            add    Prewarm cache from gem names and/or Gemfile/Gemfile.lock
+            clean  Clear the cache, removing all entries or those linked to specific packages
+            dir    Show the cache directory
+            size   Show the cache size
+        HELP
+      end
+
+      # scint cache add GEM [GEM...]
+      # scint cache add --lockfile Gemfile.lock
+      # scint cache add --gemfile Gemfile
+      def add
+        options = parse_add_options
+        if options[:gems].empty? && !options[:lockfile] && !options[:gemfile]
+          $stderr.puts "Usage: scint cache add GEM [GEM...] [--lockfile FILE] [--gemfile FILE] [--jobs N] [--force]"
+          return 1
+        end
+
+        specs = collect_specs_for_add(options)
+        prewarm = Scint::Cache::Prewarm.new(
+          cache_layout: Scint::Cache::Layout.new,
+          jobs: options[:jobs],
+          credentials: options[:credentials],
+          force: options[:force],
+        )
+        result = prewarm.run(specs)
+
+        if result[:failed] > 0
+          $stderr.puts "Cache prewarm failed for #{result[:failed]} gem(s):"
+          result[:failures].each do |failure|
+            spec = failure[:spec]
+            $stderr.puts "  #{spec.name}: #{failure[:error].message}"
+          end
+          $stdout.puts "Cache add: #{result[:warmed]} warmed, #{result[:skipped]} skipped, #{result[:ignored]} ignored."
+          return 1
+        end
+
+        $stdout.puts "Cache add complete: #{result[:warmed]} warmed, #{result[:skipped]} skipped, #{result[:ignored]} ignored."
+        0
+      end
+
+      # -- Implementation -------------------------------------------------------
+
+      def clear_all
+        entries = Dir.children(cache_root)
+        entries.each do |entry|
+          FileUtils.rm_rf(File.join(cache_root, entry))
+        end
+        entries.size
+      end
+
+      def clear_packages(packages)
+        removed = 0
+        %w[inbound extracted ext].each do |subdir|
+          subdir_path = File.join(cache_root, subdir)
+          next unless Dir.exist?(subdir_path)
+
+          Dir.children(subdir_path).each do |entry|
+            if packages.any? { |pkg| entry.start_with?(pkg) }
+              FileUtils.rm_rf(File.join(subdir_path, entry))
+              removed += 1
+            end
+          end
+        end
+        removed
+      end
+
+      def format_size(bytes)
+        if bytes < 1024
+          "#{bytes} B"
+        elsif bytes < 1024 * 1024
+          "#{(bytes / 1024.0).round(1)} KiB"
+        elsif bytes < 1024 * 1024 * 1024
+          "#{(bytes / (1024.0 * 1024)).round(1)} MiB"
+        else
+          "#{(bytes / (1024.0 * 1024 * 1024)).round(1)} GiB"
+        end
+      end
+
+      def parse_add_options
+        opts = {
+          gems: [],
+          lockfile: nil,
+          gemfile: nil,
+          jobs: nil,
+          force: false,
+          version: nil,
+          source: "https://rubygems.org",
+        }
+
+        i = 0
+        while i < @argv.length
+          token = @argv[i]
+          case token
+          when "--lockfile"
+            opts[:lockfile] = @argv[i + 1]
+            i += 2
+          when "--gemfile"
+            opts[:gemfile] = @argv[i + 1]
+            i += 2
+          when "--jobs", "-j"
+            opts[:jobs] = @argv[i + 1]&.to_i
+            i += 2
+          when "--force", "-f"
+            opts[:force] = true
+            i += 1
+          when "--version"
+            opts[:version] = @argv[i + 1]
+            i += 2
+          when "--source"
+            opts[:source] = @argv[i + 1]
+            i += 2
+          else
+            if token.start_with?("-")
+              raise CacheError, "Unknown option for cache add: #{token}"
+            end
+            opts[:gems] << token
+            i += 1
+          end
+        end
+
+        opts[:credentials] = Credentials.new
+        opts
+      end
+
+      def collect_specs_for_add(options)
+        specs = []
+        install = CLI::Install.new([])
+        install.instance_variable_set(:@credentials, options[:credentials])
+
+        if options[:lockfile]
+          lockfile = Scint::Lockfile::Parser.parse(options[:lockfile])
+          options[:credentials].register_lockfile_sources(lockfile.sources)
+          specs.concat(install.send(:lockfile_to_resolved, lockfile))
+        end
+
+        if options[:gemfile]
+          specs.concat(resolve_from_gemfile(install, options[:gemfile], options[:credentials]))
+        end
+
+        unless options[:gems].empty?
+          specs.concat(resolve_from_names(install, options))
+        end
+
+        dedupe_specs(specs)
+      end
+
+      def resolve_from_gemfile(install, gemfile_path, credentials)
+        gemfile = Scint::Gemfile::Parser.parse(gemfile_path)
+        credentials.register_sources(gemfile.sources)
+        credentials.register_dependencies(gemfile.dependencies)
+
+        lockfile_path = File.join(File.dirname(File.expand_path(gemfile_path)), "Gemfile.lock")
+        lockfile = File.exist?(lockfile_path) ? Scint::Lockfile::Parser.parse(lockfile_path) : nil
+        credentials.register_lockfile_sources(lockfile.sources) if lockfile
+
+        if lockfile && install.send(:lockfile_current?, gemfile, lockfile)
+          install.send(:lockfile_to_resolved, lockfile)
+        else
+          install.send(:resolve, gemfile, lockfile, Scint::Cache::Layout.new)
+        end
+      end
+
+      def resolve_from_names(install, options)
+        deps = options[:gems].map do |name|
+          source_options = {}
+          source_options[:source] = options[:source] if options[:source]
+          reqs = options[:version] ? [options[:version]] : [">= 0"]
+          Scint::Gemfile::Dependency.new(name, version_reqs: reqs, source_options: source_options)
+        end
+
+        gemfile = Scint::Gemfile::ParseResult.new(
+          dependencies: deps,
+          sources: [{ type: :rubygems, uri: options[:source] }],
+          ruby_version: nil,
+          platforms: [],
+        )
+
+        install.send(:resolve, gemfile, nil, Scint::Cache::Layout.new)
+      end
+
+      def dedupe_specs(specs)
+        seen = {}
+        specs.each do |spec|
+          key = "#{spec.name}-#{spec.version}-#{spec.platform}"
+          seen[key] ||= spec
+        end
+        seen.values
+      end
+    end
+  end
+end

data/lib/scint/cli/exec.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require_relative "../runtime/exec"
+require_relative "../fs"
+require_relative "../platform"
+require_relative "../lockfile/parser"
+
+module Scint
+  module CLI
+    class Exec
+      RUNTIME_LOCK = "scint.lock.marshal"
+
+      def initialize(argv = [])
+        @argv = argv
+      end
+
+      def run
+        if @argv.empty?
+          $stderr.puts "scint exec requires a command to run"
+          return 1
+        end
+
+        command = @argv.first
+        args = @argv[1..] || []
+
+        lock_path = find_lock_path
+        unless lock_path
+          $stderr.puts "No runtime lock found. Run `scint install` first."
+          return 1
+        end
+
+        # This calls Kernel.exec and never returns on success
+        Runtime::Exec.exec(command, args, lock_path)
+      end
+
+      private
+
+      def find_lock_path
+        # Walk up from cwd looking for .bundle/scint.lock.marshal.
+        # If missing but Gemfile.lock + installed gems exist, rebuild it.
+        dir = Dir.pwd
+        loop do
+          bundle_dir = File.join(dir, ".bundle")
+          candidate = File.join(dir, ".bundle", RUNTIME_LOCK)
+          return candidate if File.exist?(candidate)
+
+          rebuilt = rebuild_runtime_lock(dir, bundle_dir, candidate)
+          return rebuilt if rebuilt
+
+          parent = File.dirname(dir)
+          break if parent == dir # reached root
+          dir = parent
+        end
+
+        nil
+      end
+
+      def rebuild_runtime_lock(project_dir, bundle_dir, lock_path)
+        return nil unless Dir.exist?(File.join(bundle_dir, "ruby"))
+
+        gemfile_lock = File.join(project_dir, "Gemfile.lock")
+        return nil unless File.exist?(gemfile_lock)
+
+        ruby_dir = detect_ruby_dir(bundle_dir)
+        return nil unless ruby_dir
+
+        lockfile = Scint::Lockfile::Parser.parse(gemfile_lock)
+        data = {}
+
+        lockfile.specs.each do |spec|
+          full = spec_full_name(spec)
+          gem_dir = File.join(ruby_dir, "gems", full)
+          next unless Dir.exist?(gem_dir)
+
+          spec_file = File.join(ruby_dir, "specifications", "#{full}.gemspec")
+          require_paths = read_require_paths(spec_file)
+          load_paths = require_paths
+            .map { |rp| File.join(gem_dir, rp) }
+            .select { |path| Dir.exist?(path) }
+
+          lib_path = File.join(gem_dir, "lib")
+          load_paths << lib_path if load_paths.empty? && Dir.exist?(lib_path)
+          load_paths.concat(detect_nested_lib_paths(gem_dir))
+          load_paths.uniq!
+
+          ext_path = File.join(ruby_dir, "extensions",
+                               Platform.gem_arch, Platform.extension_api_version, full)
+          load_paths << ext_path if Dir.exist?(ext_path)
+
+          data[spec[:name]] = {
+            version: spec[:version].to_s,
+            load_paths: load_paths,
+          }
+        end
+
+        return nil if data.empty?
+
+        FS.atomic_write(lock_path, Marshal.dump(data))
+        lock_path
+      rescue StandardError
+        nil
+      end
+
+      def detect_ruby_dir(bundle_dir)
+        target = RUBY_VERSION.split(".")[0, 2].join(".") + ".0"
+        preferred = File.join(bundle_dir, "ruby", target)
+        return preferred if Dir.exist?(preferred)
+
+        dirs = Dir.glob(File.join(bundle_dir, "ruby", "*")).select { |path| Dir.exist?(path) }
+        dirs.sort.first
+      end
+
+      def spec_full_name(spec)
+        name = spec[:name]
+        version = spec[:version]
+        platform = spec[:platform]
+        base = "#{name}-#{version}"
+        return base if platform.nil? || platform.to_s == "ruby" || platform.to_s.empty?
+
+        "#{base}-#{platform}"
+      end
+
+      def read_require_paths(spec_file)
+        return ["lib"] unless File.exist?(spec_file)
+
+        gemspec = Gem::Specification.load(spec_file)
+        paths = Array(gemspec&.require_paths).reject(&:empty?)
+        paths.empty? ? ["lib"] : paths
+      rescue StandardError
+        ["lib"]
+      end
+
+      def detect_nested_lib_paths(gem_dir)
+        lib_dir = File.join(gem_dir, "lib")
+        return [] unless Dir.exist?(lib_dir)
+
+        children = Dir.children(lib_dir)
+        top_level_rb = children.any? do |entry|
+          path = File.join(lib_dir, entry)
+          File.file?(path) && entry.end_with?(".rb")
+        end
+        return [] if top_level_rb
+
+        children
+          .map { |entry| File.join(lib_dir, entry) }
+          .select { |path| File.directory?(path) }
+      end
+    end
+  end
+end