scint 0.1.0

data/lib/bundler.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "base64"
+require "scint/runtime/setup"
+require "scint/gemfile/parser"
+
+# Minimal Bundler compatibility shim for `scint exec`.
+# This intentionally implements only the subset commonly used by apps:
+# - `require "bundler/setup"` (handled by lib/bundler/setup.rb)
+# - `Bundler.setup`
+# - `Bundler.require`
+module Bundler
+  RUNTIME_LOCK = "scint.lock.marshal"
+  ORIGINAL_ENV = begin
+    encoded = ENV["SCINT_ORIGINAL_ENV"]
+    if encoded && !encoded.empty?
+      Marshal.load(Base64.decode64(encoded))
+    else
+      ENV.to_hash
+    end
+  rescue StandardError
+    ENV.to_hash
+  end
+
+  class << self
+    def setup(*_groups)
+      return @lock_data if @lock_data
+
+      lock_path = find_runtime_lock
+      unless lock_path
+        raise LoadError, "Runtime lock not found. Run `scint install` first."
+      end
+
+      ENV["SCINT_RUNTIME_LOCK"] ||= lock_path
+      @lock_data = ::Scint::Runtime::Setup.setup(lock_path)
+    end
+
+    def require(*_groups)
+      groups = _groups.flatten.compact.map(&:to_sym)
+      groups = [:default] if groups.empty?
+
+      setup
+
+      gemfile_dependencies.each do |dep|
+        next unless dependency_in_groups?(dep, groups)
+
+        targets = require_targets_for(dep)
+        targets.each { |target| require_one(target) }
+      end
+
+      true
+    end
+
+    def root
+      gemfile = ENV["BUNDLE_GEMFILE"]
+      return Pathname.new(Dir.pwd) unless gemfile && !gemfile.empty?
+
+      Pathname.new(File.dirname(gemfile))
+    end
+
+    def bundle_path
+      root.join(".bundle")
+    end
+
+    def load
+      setup
+    end
+
+    def with_unbundled_env
+      previous = ENV.to_hash
+      ENV.replace(unbundled_env)
+      yield
+    ensure
+      ENV.replace(previous) if previous
+    end
+    alias with_original_env with_unbundled_env
+
+    def original_env
+      ORIGINAL_ENV.dup
+    end
+
+    def unbundled_env
+      env = original_env
+      env["RUBYOPT"] = filter_bundler_setup_from_rubyopt(env["RUBYOPT"])
+      env.delete("SCINT_RUNTIME_LOCK")
+      env.delete("SCINT_ORIGINAL_ENV")
+      env
+    end
+
+    private
+
+    def require_one(gem_name)
+      name = gem_name.to_s
+      candidates = [name, name.tr("-", "_"), name.tr("-", "/")].uniq
+      last_error = nil
+
+      candidates.each do |candidate|
+        begin
+          Kernel.require(candidate)
+          return true
+        rescue LoadError => e
+          last_error = e
+        end
+      end
+
+      raise last_error if last_error
+    end
+
+    def gemfile_dependencies
+      return @gemfile_dependencies if defined?(@gemfile_dependencies)
+
+      gemfile = ENV["BUNDLE_GEMFILE"]
+      @gemfile_dependencies =
+        if gemfile && File.exist?(gemfile)
+          ::Scint::Gemfile::Parser.parse(gemfile).dependencies
+        else
+          []
+        end
+    rescue StandardError
+      @gemfile_dependencies = []
+    end
+
+    def dependency_in_groups?(dep, groups)
+      dep_groups = Array(dep.groups).map(&:to_sym)
+      (dep_groups & groups).any?
+    end
+
+    def require_targets_for(dep)
+      req = dep.require_paths
+      return [] if req == []
+      return [dep.name] if req.nil?
+
+      Array(req)
+    end
+
+    def find_runtime_lock
+      env_path = ENV["SCINT_RUNTIME_LOCK"]
+      return env_path if env_path && File.exist?(env_path)
+
+      gemfile = ENV["BUNDLE_GEMFILE"]
+      if gemfile && !gemfile.empty?
+        candidate = File.join(File.dirname(gemfile), ".bundle", RUNTIME_LOCK)
+        return candidate if File.exist?(candidate)
+      end
+
+      dir = Dir.pwd
+      loop do
+        candidate = File.join(dir, ".bundle", RUNTIME_LOCK)
+        return candidate if File.exist?(candidate)
+
+        parent = File.dirname(dir)
+        break if parent == dir
+        dir = parent
+      end
+
+      nil
+    end
+
+    def filter_bundler_setup_from_rubyopt(value)
+      parts = value.to_s.split(/\s+/).reject(&:empty?)
+      filtered = parts.reject do |entry|
+        entry == "-rbundler/setup" || entry.end_with?("/bundler/setup")
+      end
+      filtered.join(" ")
+    end
+  end
+end

data/lib/scint/cache/layout.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require_relative "../fs"
+require_relative "../platform"
+require "digest"
+require "uri"
+
+module Scint
+  module Cache
+    class Layout
+      attr_reader :root
+
+      def initialize(root: nil)
+        @root = root || default_root
+        @ensured_dirs = {}
+        @mutex = Thread::Mutex.new
+      end
+
+      # -- Top-level directories -----------------------------------------------
+
+      def inbound_dir
+        File.join(@root, "inbound")
+      end
+
+      def extracted_dir
+        File.join(@root, "extracted")
+      end
+
+      def ext_dir
+        File.join(@root, "ext")
+      end
+
+      def index_dir
+        File.join(@root, "index")
+      end
+
+      def git_dir
+        File.join(@root, "git")
+      end
+
+      # Isolated gem home used while compiling native extensions during install.
+      # This keeps build-time gem activation hermetic to scint-managed paths.
+      def install_env_dir
+        File.join(@root, "install-env")
+      end
+
+      def install_ruby_dir
+        File.join(install_env_dir, "ruby", RUBY_VERSION.split(".")[0, 2].join(".") + ".0")
+      end
+
+      # -- Per-spec paths ------------------------------------------------------
+
+      def inbound_path(spec)
+        File.join(inbound_dir, "#{full_name(spec)}.gem")
+      end
+
+      def extracted_path(spec)
+        File.join(extracted_dir, full_name(spec))
+      end
+
+      def spec_cache_path(spec)
+        File.join(extracted_dir, "#{full_name(spec)}.spec.marshal")
+      end
+
+      def ext_path(spec, abi_key = Platform.abi_key)
+        File.join(ext_dir, abi_key, full_name(spec))
+      end
+
+      # -- Per-source paths ----------------------------------------------------
+
+      def index_path(source)
+        slug = if source.respond_to?(:cache_slug)
+                 source.cache_slug
+               else
+                 slugify_uri(source.to_s)
+               end
+        File.join(index_dir, slug)
+      end
+
+      def git_path(uri)
+        slug = Digest::SHA256.hexdigest(uri.to_s)[0, 16]
+        File.join(git_dir, slug)
+      end
+
+      # -- Helpers -------------------------------------------------------------
+
+      def full_name(spec)
+        name = spec.respond_to?(:name) ? spec.name : spec[:name]
+        version = spec.respond_to?(:version) ? spec.version : spec[:version]
+        platform = spec.respond_to?(:platform) ? spec.platform : spec[:platform]
+
+        base = "#{name}-#{version}"
+        if platform && platform.to_s != "ruby" && platform.to_s != ""
+          "#{base}-#{platform}"
+        else
+          base
+        end
+      end
+
+      # Ensure a directory exists (thread-safe, cached).
+      def ensure_dir(path)
+        return if @ensured_dirs[path]
+
+        @mutex.synchronize do
+          return if @ensured_dirs[path]
+          FS.mkdir_p(path)
+          @ensured_dirs[path] = true
+        end
+      end
+
+      private
+
+      def default_root
+        base = ENV["XDG_CACHE_HOME"] || File.join(Dir.home, ".cache")
+        File.join(base, "scint")
+      end
+
+      def slugify_uri(str)
+        uri = URI.parse(str) rescue nil
+        if uri && uri.host
+          path = uri.path.to_s.gsub("/", "-").sub(/^-/, "")
+          slug = uri.host
+          slug += path unless path.empty? || path == "-"
+          slug
+        else
+          Digest::SHA256.hexdigest(str)[0, 16]
+        end
+      end
+    end
+  end
+end

data/lib/scint/cache/metadata_store.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "../fs"
+
+module Scint
+  module Cache
+    class MetadataStore
+      def initialize(path)
+        @path = path
+        @data = nil
+        @mutex = Thread::Mutex.new
+      end
+
+      # Load specs hash from disk. Returns {} if file missing or corrupt.
+      def load
+        @mutex.synchronize do
+          return @data if @data
+          @data = load_from_disk
+        end
+      end
+
+      # Save specs hash to disk atomically.
+      def save(specs_hash)
+        @mutex.synchronize do
+          @data = specs_hash
+          FS.atomic_write(@path, Marshal.dump(specs_hash))
+        end
+      end
+
+      # Check if a gem is installed. specs_hash keys are "name-version" or "name-version-platform".
+      def installed?(name, version, platform = "ruby")
+        data = load
+        key = cache_key(name, version, platform)
+        data.key?(key)
+      end
+
+      # Add a single entry.
+      def add(name, version, platform = "ruby")
+        @mutex.synchronize do
+          @data ||= load_from_disk
+          key = cache_key(name, version, platform)
+          @data[key] = true
+          FS.atomic_write(@path, Marshal.dump(@data))
+        end
+      end
+
+      # Remove a single entry.
+      def remove(name, version, platform = "ruby")
+        @mutex.synchronize do
+          @data ||= load_from_disk
+          key = cache_key(name, version, platform)
+          @data.delete(key)
+          FS.atomic_write(@path, Marshal.dump(@data))
+        end
+      end
+
+      private
+
+      def cache_key(name, version, platform)
+        if platform && platform.to_s != "ruby" && platform.to_s != ""
+          "#{name}-#{version}-#{platform}"
+        else
+          "#{name}-#{version}"
+        end
+      end
+
+      def load_from_disk
+        return {} unless File.exist?(@path)
+        Marshal.load(File.binread(@path))
+      rescue ArgumentError, TypeError, EOFError
+        {}
+      end
+    end
+  end
+end

data/lib/scint/cache/prewarm.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "layout"
+require_relative "../errors"
+require_relative "../downloader/pool"
+require_relative "../gem/package"
+require_relative "../fs"
+require_relative "../platform"
+require_relative "../worker_pool"
+
+module Scint
+  module Cache
+    class Prewarm
+      Task = Struct.new(:spec, :download, :extract, keyword_init: true)
+
+      def initialize(cache_layout: Layout.new, jobs: nil, credentials: nil, force: false,
+                     downloader_factory: nil)
+        @cache = cache_layout
+        @jobs = [[jobs || (Platform.cpu_count * 2), 1].max, 50].min
+        @credentials = credentials
+        @force = force
+        @downloader_factory = downloader_factory || lambda { |size, creds|
+          Downloader::Pool.new(size: size, credentials: creds)
+        }
+      end
+
+      # Returns summary hash:
+      # { warmed:, skipped:, ignored:, failed:, failures: [] }
+      def run(specs)
+        failures = []
+        ignored = 0
+        skipped = 0
+
+        tasks = []
+        specs.each do |spec|
+          if prewarmable?(spec)
+            tasks << task_for(spec)
+          else
+            ignored += 1
+          end
+        end
+
+        tasks.each do |task|
+          next unless @force
+
+          purge_artifacts(task.spec)
+          task.download = true
+          task.extract = true
+        end
+
+        tasks.each do |task|
+          if !task.download && !task.extract
+            skipped += 1
+          end
+        end
+
+        work_tasks = tasks.select { |task| task.download || task.extract }
+        return result_hash(work_tasks.size, skipped, ignored, failures) if work_tasks.empty?
+
+        download_errors = download_tasks(work_tasks.select(&:download))
+        failures.concat(download_errors)
+
+        remaining = work_tasks.reject do |task|
+          failures.any? { |f| f[:spec] == task.spec }
+        end
+
+        extract_errors = extract_tasks(remaining.select(&:extract))
+        failures.concat(extract_errors)
+
+        result_hash(work_tasks.size - failures.size, skipped, ignored, failures)
+      end
+
+      private
+
+      def task_for(spec)
+        inbound = @cache.inbound_path(spec)
+        extracted = @cache.extracted_path(spec)
+        metadata = @cache.spec_cache_path(spec)
+
+        Task.new(
+          spec: spec,
+          download: !File.exist?(inbound),
+          extract: !Dir.exist?(extracted) || !File.exist?(metadata),
+        )
+      end
+
+      def prewarmable?(spec)
+        source = spec.source
+        source_str = source.to_s
+        source_str.start_with?("http://", "https://")
+      end
+
+      def download_tasks(tasks)
+        return [] if tasks.empty?
+
+        downloader = @downloader_factory.call(@jobs, @credentials)
+        items = tasks.map do |task|
+          spec = task.spec
+          {
+            spec: spec,
+            uri: download_uri_for(spec),
+            dest: @cache.inbound_path(spec),
+            checksum: spec.respond_to?(:checksum) ? spec.checksum : nil,
+          }
+        end
+
+        results = downloader.download_batch(items)
+        failures = results.select { |r| r[:error] }.map do |r|
+          { spec: r[:spec], error: r[:error] }
+        end
+        failures
+      ensure
+        downloader&.close
+      end
+
+      def extract_tasks(tasks)
+        return [] if tasks.empty?
+
+        failures = []
+        mutex = Thread::Mutex.new
+        done = Thread::Queue.new
+
+        pool = WorkerPool.new(@jobs, name: "prewarm-extract")
+        pool.start do |task|
+          spec = task.spec
+          inbound = @cache.inbound_path(spec)
+
+          unless File.exist?(inbound)
+            raise CacheError, "Missing downloaded gem for #{spec.name}: #{inbound}"
+          end
+
+          extracted = @cache.extracted_path(spec)
+          metadata = @cache.spec_cache_path(spec)
+
+          gemspec = nil
+          if task.extract
+            FileUtils.rm_rf(extracted)
+            FS.mkdir_p(extracted)
+            result = GemPkg::Package.new.extract(inbound, extracted)
+            gemspec = result[:gemspec]
+          elsif !File.exist?(metadata)
+            gemspec = GemPkg::Package.new.read_metadata(inbound)
+          end
+
+          if gemspec
+            FS.atomic_write(metadata, gemspec.to_yaml)
+          end
+
+          true
+        end
+
+        tasks.each do |task|
+          pool.enqueue(task) do |job|
+            mutex.synchronize do
+              if job[:state] == :failed
+                failures << { spec: job[:payload].spec, error: job[:error] }
+              end
+            end
+            done.push(true)
+          end
+        end
+
+        tasks.size.times { done.pop }
+        pool.stop
+
+        failures
+      end
+
+      def download_uri_for(spec)
+        source = spec.source.to_s.chomp("/")
+        "#{source}/gems/#{@cache.full_name(spec)}.gem"
+      end
+
+      def purge_artifacts(spec)
+        FileUtils.rm_f(@cache.inbound_path(spec))
+        FileUtils.rm_rf(@cache.extracted_path(spec))
+        FileUtils.rm_f(@cache.spec_cache_path(spec))
+      end
+
+      def result_hash(warmed, skipped, ignored, failures)
+        {
+          warmed: warmed,
+          skipped: skipped,
+          ignored: ignored,
+          failed: failures.size,
+          failures: failures,
+        }
+      end
+    end
+  end
+end

data/lib/scint/cli/add.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+require_relative "../gemfile/editor"
+require_relative "install"
+
+module Scint
+  module CLI
+    class Add
+      def initialize(argv = [])
+        @argv = argv.dup
+        @skip_install = false
+        @requirement = nil
+        @group = nil
+        @source = nil
+        @git = nil
+        @path = nil
+        parse_options
+      end
+
+      def run
+        if @gems.empty?
+          $stderr.puts "Usage: scint add GEM [GEM...] [options]"
+          return 1
+        end
+
+        editor = Gemfile::Editor.new("Gemfile")
+        @gems.each do |gem_name|
+          result = editor.add(
+            gem_name,
+            requirement: @requirement,
+            group: @group,
+            source: @source,
+            git: @git,
+            path: @path,
+          )
+
+          action = result == :updated ? "Updated" : "Added"
+          $stdout.puts "#{action} #{gem_name} in Gemfile"
+        end
+
+        return 0 if @skip_install
+
+        CLI::Install.new([]).run
+      end
+
+      private
+
+      def parse_options
+        @gems = []
+        i = 0
+        while i < @argv.length
+          token = @argv[i]
+
+          case token
+          when "--skip-install"
+            @skip_install = true
+            i += 1
+          when "--version"
+            @requirement = @argv[i + 1]
+            i += 2
+          when "--group"
+            @group = @argv[i + 1]
+            i += 2
+          when "--source"
+            @source = @argv[i + 1]
+            i += 2
+          when "--git"
+            @git = @argv[i + 1]
+            i += 2
+          when "--path"
+            @path = @argv[i + 1]
+            i += 2
+          else
+            if token.start_with?("-")
+              raise GemfileError, "Unknown option for add: #{token}"
+            end
+            @gems << token
+            i += 1
+          end
+        end
+      end
+    end
+  end
+end