scint 0.1.0

data/lib/scint/downloader/fetcher.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "fileutils"
+require_relative "../fs"
+require_relative "../errors"
+
+module Scint
+  module Downloader
+    class Fetcher
+      MAX_REDIRECTS = 5
+
+      def initialize(credentials: nil)
+        @connections = {} # "host:port" => Net::HTTP
+        @mutex = Thread::Mutex.new
+        @credentials = credentials
+      end
+
+      # Download a single file from uri to dest_path.
+      # Streams to a temp file then atomically renames.
+      # Returns { path: dest_path, size: bytes }
+      def fetch(uri, dest_path, checksum: nil)
+        uri = URI.parse(uri) unless uri.is_a?(URI)
+        FS.mkdir_p(File.dirname(dest_path))
+
+        tmp_path = "#{dest_path}.#{Process.pid}.#{Thread.current.object_id}.tmp"
+        size = 0
+
+        begin
+          redirect_count = 0
+          current_uri = uri
+
+          loop do
+            http = connection_for(current_uri)
+            request = Net::HTTP::Get.new(current_uri.request_uri)
+            request["Accept-Encoding"] = "identity"
+            @credentials&.apply!(request, current_uri)
+
+            response = http.request(request)
+
+            case response
+            when Net::HTTPSuccess
+              File.open(tmp_path, "wb") do |f|
+                body = response.body
+                f.write(body)
+                size = body.bytesize
+              end
+              break
+            when Net::HTTPRedirection
+              redirect_count += 1
+              raise NetworkError, "Too many redirects for #{uri}" if redirect_count > MAX_REDIRECTS
+              location = response["location"]
+              current_uri = URI.parse(location)
+              next
+            else
+              raise NetworkError, "HTTP #{response.code} for #{uri}: #{response.message}"
+            end
+          end
+
+          if checksum
+            actual = Digest::SHA256.file(tmp_path).hexdigest
+            unless actual == checksum
+              File.delete(tmp_path) if File.exist?(tmp_path)
+              raise NetworkError, "Checksum mismatch for #{uri}: expected #{checksum}, got #{actual}"
+            end
+          end
+
+          File.rename(tmp_path, dest_path)
+          { path: dest_path, size: size }
+        rescue StandardError
+          File.delete(tmp_path) if File.exist?(tmp_path)
+          raise
+        end
+      end
+
+      # Close all persistent connections.
+      def close
+        @mutex.synchronize do
+          @connections.each_value do |http|
+            http.finish if http.started?
+          rescue StandardError
+            # ignore close errors
+          end
+          @connections.clear
+        end
+      end
+
+      private
+
+      def connection_for(uri)
+        key = "#{uri.host}:#{uri.port}:#{uri.scheme}"
+
+        @mutex.synchronize do
+          http = @connections[key]
+          if http && http.started?
+            return http
+          end
+
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = (uri.scheme == "https")
+          http.open_timeout = 10
+          http.read_timeout = 30
+          http.keep_alive_timeout = 30
+          http.start
+
+          @connections[key] = http
+          http
+        end
+      end
+    end
+  end
+end

data/lib/scint/downloader/pool.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require_relative "fetcher"
+require_relative "../worker_pool"
+require_relative "../platform"
+require_relative "../errors"
+
+module Scint
+  module Downloader
+    class Pool
+      MAX_RETRIES = 3
+      BACKOFF_BASE = 0.5 # seconds
+
+      attr_reader :size
+
+      def initialize(size: nil, on_progress: nil, credentials: nil)
+        @size = size || [Platform.cpu_count * 2, 50].min
+        @on_progress = on_progress
+        @credentials = credentials
+        @fetchers = {} # thread_id => Fetcher
+        @fetcher_mutex = Thread::Mutex.new
+      end
+
+      # Download a single URI to dest_path with retry logic.
+      # Returns { path:, size: }
+      def download(uri, dest_path, checksum: nil)
+        retries = 0
+        begin
+          fetcher = thread_fetcher
+          fetcher.fetch(uri, dest_path, checksum: checksum)
+        rescue NetworkError, Errno::ECONNRESET, Errno::ECONNREFUSED,
+               Errno::ETIMEDOUT, Net::ReadTimeout, Net::OpenTimeout,
+               SocketError, IOError => e
+          retries += 1
+          if retries <= MAX_RETRIES
+            sleep(BACKOFF_BASE * (2**(retries - 1)))
+            # Reset connection on retry
+            reset_thread_fetcher
+            retry
+          end
+          raise NetworkError, "Failed to download #{uri} after #{MAX_RETRIES} retries: #{e.message}"
+        end
+      end
+
+      # Download multiple items concurrently.
+      # items: [{ uri:, dest:, spec:, checksum: }]
+      # Returns array of { spec:, path:, size:, error: }
+      def download_batch(items)
+        results = []
+        result_mutex = Thread::Mutex.new
+
+        pool = WorkerPool.new(@size, name: "download")
+        remaining = items.size
+
+        done = Thread::Queue.new
+
+        pool.start do |item|
+          result = download_one(item)
+          result_mutex.synchronize { results << result }
+          @on_progress&.call(result)
+          done.push(true)
+          result
+        end
+
+        items.each { |item| pool.enqueue(item) }
+
+        remaining.times { done.pop }
+        pool.stop
+
+        results
+      end
+
+      # Close all connections across all threads.
+      def close
+        @fetcher_mutex.synchronize do
+          @fetchers.each_value(&:close)
+          @fetchers.clear
+        end
+      end
+
+      private
+
+      def download_one(item)
+        uri = item[:uri]
+        dest = item[:dest]
+        spec = item[:spec]
+        checksum = item[:checksum]
+
+        result = download(uri, dest, checksum: checksum)
+        { spec: spec, path: result[:path], size: result[:size], error: nil }
+      rescue StandardError => e
+        { spec: spec, path: nil, size: 0, error: e }
+      end
+
+      # Each thread gets its own Fetcher for connection reuse without locking.
+      def thread_fetcher
+        tid = Thread.current.object_id
+        @fetcher_mutex.synchronize do
+          @fetchers[tid] ||= Fetcher.new(credentials: @credentials)
+        end
+      end
+
+      def reset_thread_fetcher
+        tid = Thread.current.object_id
+        @fetcher_mutex.synchronize do
+          old = @fetchers.delete(tid)
+          old&.close
+        end
+      end
+    end
+  end
+end

data/lib/scint/errors.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Scint
+  class BundlerError < StandardError
+    def status_code
+      1
+    end
+  end
+
+  class GemfileError < BundlerError
+    def status_code
+      4
+    end
+  end
+
+  class LockfileError < BundlerError
+    def status_code
+      5
+    end
+  end
+
+  class ResolveError < BundlerError
+    def status_code
+      6
+    end
+  end
+
+  class NetworkError < BundlerError
+    def status_code
+      7
+    end
+  end
+
+  class InstallError < BundlerError
+    def status_code
+      8
+    end
+  end
+
+  class ExtensionBuildError < InstallError
+    def status_code
+      9
+    end
+  end
+
+  class PermissionError < BundlerError
+    def status_code
+      10
+    end
+  end
+
+  class PlatformError < BundlerError
+    def status_code
+      11
+    end
+  end
+
+  class CacheError < BundlerError
+    def status_code
+      12
+    end
+  end
+end

data/lib/scint/fs.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "tmpdir"
+
+module Scint
+  module FS
+    module_function
+
+    # Cache of directories we've already ensured exist, to avoid repeated syscalls.
+    @mkdir_cache = {}
+    @mkdir_mutex = Thread::Mutex.new
+
+    def mkdir_p(path)
+      path = path.to_s
+      return if @mkdir_cache[path]
+
+      # Do the filesystem call outside the cache mutex so unrelated directory
+      # creation can proceed in parallel across worker threads.
+      FileUtils.mkdir_p(path)
+      @mkdir_mutex.synchronize { @mkdir_cache[path] = true }
+    end
+
+    # APFS clonefile (CoW copy). Falls back to hardlink, then regular copy.
+    def clonefile(src, dst)
+      src = src.to_s
+      dst = dst.to_s
+      mkdir_p(File.dirname(dst))
+
+      # Try APFS clonefile via cp -c (macOS)
+      if Platform.macos?
+        return if system("cp", "-c", src, dst, [:out, :err] => File::NULL)
+      end
+
+      # Fallback: hardlink
+      begin
+        File.link(src, dst)
+        return
+      rescue SystemCallError
+        # cross-device or unsupported
+      end
+
+      # Final fallback: regular copy
+      FileUtils.cp(src, dst)
+    end
+
+    # Recursively hardlink all files from src_dir into dst_dir.
+    # Directory structure is recreated; files are hardlinked.
+    def hardlink_tree(src_dir, dst_dir)
+      src_dir = src_dir.to_s
+      dst_dir = dst_dir.to_s
+      raise Errno::ENOENT, src_dir unless Dir.exist?(src_dir)
+      mkdir_p(dst_dir)
+
+      queue = [[src_dir, dst_dir]]
+      until queue.empty?
+        src_root, dst_root = queue.shift
+
+        Dir.each_child(src_root) do |entry|
+          src_path = File.join(src_root, entry)
+          dst_path = File.join(dst_root, entry)
+          stat = File.lstat(src_path)
+
+          if stat.directory?
+            mkdir_p(dst_path)
+            queue << [src_path, dst_path]
+            next
+          end
+
+          mkdir_p(File.dirname(dst_path))
+          begin
+            File.link(src_path, dst_path)
+          rescue SystemCallError
+            FileUtils.cp(src_path, dst_path)
+          end
+        end
+      end
+    end
+
+    # Atomic move: rename with cross-device fallback.
+    def atomic_move(src, dst)
+      src = src.to_s
+      dst = dst.to_s
+      mkdir_p(File.dirname(dst))
+
+      begin
+        File.rename(src, dst)
+      rescue Errno::EXDEV
+        # Cross-device: copy then remove
+        tmp = "#{dst}.#{Process.pid}.#{Thread.current.object_id}"
+        if File.directory?(src)
+          FileUtils.cp_r(src, tmp)
+        else
+          FileUtils.cp(src, tmp)
+        end
+        File.rename(tmp, dst)
+        FileUtils.rm_rf(src)
+      end
+    end
+
+    # Create a temporary directory, yield it, clean up on error.
+    def with_tempdir(prefix = "scint")
+      dir = Dir.mktmpdir(prefix)
+      yield dir
+    rescue StandardError
+      FileUtils.rm_rf(dir) if dir && File.exist?(dir)
+      raise
+    end
+
+    # Write to a temp file then atomically rename into place.
+    def atomic_write(path, content)
+      path = path.to_s
+      mkdir_p(File.dirname(path))
+      tmp = "#{path}.#{Process.pid}.#{Thread.current.object_id}.tmp"
+      File.binwrite(tmp, content)
+      File.rename(tmp, path)
+    end
+  end
+end

data/lib/scint/gem/extractor.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "rubygems/package"
+require "zlib"
+require "fileutils"
+require_relative "../fs"
+
+module Scint
+  module GemPkg
+    class Extractor
+      # Extract data.tar.gz contents into dest_dir.
+      # Primary: shell out to system tar for speed.
+      # Fallback: pure Ruby extraction.
+      def extract(data_tar_gz_path, dest_dir)
+        FS.mkdir_p(dest_dir)
+
+        if system_tar_available?
+          extract_with_system_tar(data_tar_gz_path, dest_dir)
+        else
+          extract_with_ruby(data_tar_gz_path, dest_dir)
+        end
+
+        dest_dir
+      end
+
+      private
+
+      def system_tar_available?
+        @system_tar_available = system("tar", "--version", [:out, :err] => File::NULL) if @system_tar_available.nil?
+        @system_tar_available
+      rescue Errno::ENOENT
+        @system_tar_available = false
+      end
+
+      def extract_with_system_tar(data_tar_gz_path, dest_dir)
+        result = system("tar", "xzf", data_tar_gz_path, "-C", dest_dir)
+        return if result
+
+        # If system tar fails, fall back to Ruby
+        extract_with_ruby(data_tar_gz_path, dest_dir)
+      end
+
+      def extract_with_ruby(data_tar_gz_path, dest_dir)
+        File.open(data_tar_gz_path, "rb") do |file|
+          gz = Zlib::GzipReader.new(file)
+          tar = ::Gem::Package::TarReader.new(gz)
+
+          tar.each do |entry|
+            dest_path = File.join(dest_dir, entry.full_name)
+
+            # Security: prevent path traversal
+            unless safe_path?(dest_dir, dest_path)
+              next
+            end
+
+            if entry.directory?
+              FS.mkdir_p(dest_path)
+            elsif entry.symlink?
+              # Only follow symlinks that stay inside dest_dir
+              link_target = File.expand_path(entry.header.linkname, File.dirname(dest_path))
+              if safe_path?(dest_dir, link_target)
+                FS.mkdir_p(File.dirname(dest_path))
+                File.symlink(entry.header.linkname, dest_path)
+              end
+            elsif entry.file?
+              FS.mkdir_p(File.dirname(dest_path))
+              File.open(dest_path, "wb") do |f|
+                while (chunk = entry.read(16384))
+                  f.write(chunk)
+                end
+              end
+              File.chmod(entry.header.mode, dest_path) if entry.header.mode
+            end
+          end
+        end
+      end
+
+      # Ensure dest_path is inside base_dir (prevent directory traversal).
+      def safe_path?(base_dir, dest_path)
+        expanded = File.expand_path(dest_path)
+        expanded_base = File.expand_path(base_dir)
+        expanded.start_with?("#{expanded_base}/") || expanded == expanded_base
+      end
+    end
+  end
+end

data/lib/scint/gem/package.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "rubygems/package"
+require "zlib"
+require "stringio"
+require_relative "extractor"
+require_relative "../fs"
+
+module Scint
+  module GemPkg
+    class Package
+      # Read gemspec from a .gem file without full extraction.
+      # Returns a Gem::Specification.
+      def read_metadata(gem_path)
+        File.open(gem_path, "rb") do |io|
+          tar = ::Gem::Package::TarReader.new(io)
+          tar.each do |entry|
+            if entry.full_name == "metadata.gz"
+              gz = Zlib::GzipReader.new(StringIO.new(entry.read))
+              return ::Gem::Specification.from_yaml(gz.read)
+            end
+          end
+        end
+        raise InstallError, "No metadata.gz found in #{gem_path}"
+      end
+
+      # Single-pass extraction: reads the .gem TAR once, extracts both
+      # metadata.gz (gemspec) and data.tar.gz (files) in one pass.
+      # Returns { gemspec: Gem::Specification, extracted_path: dest_dir }
+      def extract(gem_path, dest_dir)
+        FS.mkdir_p(dest_dir)
+        gemspec = nil
+        data_tar_gz = nil
+
+        File.open(gem_path, "rb") do |io|
+          tar = ::Gem::Package::TarReader.new(io)
+          tar.each do |entry|
+            case entry.full_name
+            when "metadata.gz"
+              gz = Zlib::GzipReader.new(StringIO.new(entry.read))
+              gemspec = ::Gem::Specification.from_yaml(gz.read)
+            when "data.tar.gz"
+              # Write data.tar.gz to a temp file for extraction
+              tmp = File.join(dest_dir, ".data.tar.gz.tmp")
+              File.open(tmp, "wb") { |f| f.write(entry.read) }
+              data_tar_gz = tmp
+            end
+          end
+        end
+
+        raise InstallError, "No metadata.gz in #{gem_path}" unless gemspec
+
+        if data_tar_gz
+          Extractor.new.extract(data_tar_gz, dest_dir)
+          File.delete(data_tar_gz) if File.exist?(data_tar_gz)
+        end
+
+        { gemspec: gemspec, extracted_path: dest_dir }
+      end
+    end
+  end
+end

data/lib/scint/gemfile/dependency.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Scint
+  module Gemfile
+    # Represents a single gem dependency declared in a Gemfile.
+    # This is an intermediate type used during Gemfile parsing;
+    # the resolver and installer use the top-level Scint::Dependency struct.
+    class Dependency
+      attr_reader :name, :version_reqs, :groups, :platforms, :require_paths, :source_options
+
+      def initialize(name, version_reqs: [], groups: [:default], platforms: [],
+                     require_paths: nil, source_options: {})
+        @name = name.to_s.freeze
+        @version_reqs = version_reqs.empty? ? [">= 0"] : version_reqs
+        @groups = groups.map(&:to_sym)
+        @platforms = platforms.map(&:to_sym)
+        @require_paths = require_paths
+        @source_options = source_options
+      end
+
+      def to_s
+        if version_reqs == [">= 0"]
+          name
+        else
+          "#{name} (#{version_reqs.join(", ")})"
+        end
+      end
+    end
+  end
+end

data/lib/scint/gemfile/editor.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+
+module Scint
+  module Gemfile
+    # Lightweight text editor for common Gemfile dependency updates.
+    #
+    # Handles single-line `gem` declarations, which is enough for the
+    # fast-path workflows used by `scint add` and `scint remove`.
+    class Editor
+      def initialize(path = "Gemfile")
+        @path = path
+      end
+
+      def add(name, requirement: nil, group: nil, source: nil, git: nil, path: nil)
+        content = read
+        line = build_line(
+          name,
+          requirement: requirement,
+          group: group,
+          source: source,
+          git: git,
+          path: path,
+        )
+
+        updated = false
+        out_lines = content.lines.map do |l|
+          if gem_line_for?(l, name)
+            updated = true
+            "#{line}\n"
+          else
+            l
+          end
+        end
+
+        unless updated
+          out_lines << "\n" unless out_lines.empty? || out_lines.last.end_with?("\n\n")
+          out_lines << "#{line}\n"
+        end
+
+        write(out_lines.join)
+        updated ? :updated : :added
+      end
+
+      def remove(name)
+        content = read
+        removed = false
+
+        out_lines = content.lines.reject do |line|
+          match = gem_line_for?(line, name)
+          removed ||= match
+          match
+        end
+
+        write(out_lines.join)
+        removed
+      end
+
+      private
+
+      def read
+        unless File.exist?(@path)
+          raise GemfileError, "Gemfile not found at #{@path}"
+        end
+
+        File.read(@path)
+      end
+
+      def write(content)
+        File.write(@path, content)
+      end
+
+      def gem_line_for?(line, name)
+        line.match?(/^\s*gem\s+["']#{Regexp.escape(name)}["'](?:\s|,|$)/)
+      end
+
+      def build_line(name, requirement:, group:, source:, git:, path:)
+        parts = ["gem #{name.inspect}"]
+        parts << requirement.inspect if requirement && !requirement.empty?
+
+        opts = []
+        opts << "group: :#{group}" if group
+        opts << "source: #{source.inspect}" if source
+        opts << "git: #{git.inspect}" if git
+        opts << "path: #{path.inspect}" if path
+
+        parts << opts.join(", ") unless opts.empty?
+        parts.join(", ")
+      end
+    end
+  end
+end