scint 0.1.0

data/lib/scint/cli/remove.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+require_relative "../gemfile/editor"
+require_relative "install"
+
+module Scint
+  module CLI
+    class Remove
+      def initialize(argv = [])
+        @argv = argv.dup
+        @skip_install = false
+        parse_options
+      end
+
+      def run
+        if @gems.empty?
+          $stderr.puts "Usage: scint remove GEM [GEM...] [--skip-install]"
+          return 1
+        end
+
+        editor = Gemfile::Editor.new("Gemfile")
+
+        @gems.each do |gem_name|
+          if editor.remove(gem_name)
+            $stdout.puts "Removed #{gem_name} from Gemfile"
+          else
+            $stdout.puts "No Gemfile entry found for #{gem_name}"
+          end
+        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
+          else
+            if token.start_with?("-")
+              raise GemfileError, "Unknown option for remove: #{token}"
+            end
+            @gems << token
+            i += 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/scint/cli.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Scint
+  module CLI
+    COMMANDS = %w[install add remove exec cache version help].freeze
+
+    def self.run(argv)
+      argv = argv.dup
+      command = argv.shift || "install"
+
+      case command
+      when "install", "i"
+        require_relative "cli/install"
+        CLI::Install.new(argv).run
+      when "add"
+        require_relative "cli/add"
+        CLI::Add.new(argv).run
+      when "remove", "rm"
+        require_relative "cli/remove"
+        CLI::Remove.new(argv).run
+      when "exec", "e"
+        require_relative "cli/exec"
+        CLI::Exec.new(argv).run
+      when "cache", "c"
+        require_relative "cli/cache"
+        CLI::Cache.new(argv).run
+      when "version", "-v", "--version"
+        $stdout.puts "scint #{Scint::VERSION}"
+        0
+      when "help", "-h", "--help"
+        print_help
+        0
+      else
+        $stderr.puts "Unknown command: #{command}"
+        $stderr.puts "Run 'scint help' for usage."
+        1
+      end
+    rescue BundlerError => e
+      $stderr.puts "Error: #{e.message}"
+      e.status_code
+    rescue Interrupt
+      $stderr.puts "\nInterrupted"
+      130
+    rescue => e
+      $stderr.puts "Fatal: #{e.class}: #{e.message}"
+      $stderr.puts e.backtrace.first(10).map { |l| "  #{l}" }.join("\n")
+      1
+    end
+
+    def self.print_help
+      $stdout.puts <<~HELP
+        Usage: scint COMMAND [OPTIONS]
+
+        Commands:
+          install    Install gems from Gemfile (default)
+          add        Add gem(s) to Gemfile and install
+          remove     Remove gem(s) from Gemfile and install
+          exec       Execute a command in the bundle context
+          cache      Manage scint cache (list/clear/dir)
+          version    Print version
+          help       Show this help
+
+        Options:
+          --jobs N   Number of parallel workers (default: auto)
+          --path P   Install gems to path
+          --verbose  Verbose output
+          --force    Reinstall all gems, ignoring cache and local bundle state
+
+        Debug ENV:
+          SCINT_PROFILE=/tmp/scint-profile.json     Write Ruby sampling profile
+          SCINT_PROFILE_HZ=250                      Sampler frequency
+          SCINT_PROFILE_DEPTH=40                    Max stack depth
+          SCINT_IO_TRACE=/tmp/scint-io.jsonl        Write JSONL IO trace
+      HELP
+    end
+  end
+end

data/lib/scint/commands/exec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "../cli/exec"
+
+module Scint
+  module Commands
+    class Exec
+      def initialize(argv)
+        @impl = CLI::Exec.new(argv)
+      end
+
+      def run
+        @impl.run
+      end
+    end
+  end
+end

data/lib/scint/commands/install.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "../cli/install"
+
+module Scint
+  module Commands
+    class Install
+      def initialize(argv)
+        @impl = CLI::Install.new(argv)
+      end
+
+      def run
+        @impl.run
+      end
+    end
+  end
+end

data/lib/scint/credentials.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "uri"
+require "cgi"
+
+module Scint
+  # Session-scoped credential store for HTTP gem sources.
+  #
+  # Assembled early from config files, then enriched as Gemfiles and lockfiles
+  # are parsed. By download time, all credentials are available.
+  #
+  # Lookup order (first match wins):
+  #   1. Inline credentials in the request URI itself (user:pass@host)
+  #   2. Credentials registered at runtime (from Gemfile source: URIs)
+  #   3. Scint config:   $XDG_CONFIG_HOME/scint/credentials
+  #   4. Bundler config:  ~/.bundle/config
+  #   5. Environment variables (BUNDLE_HOST__NAME format)
+  #
+  # All config files use Bundler's key format:
+  #   BUNDLE_PKGS__SHOPIFY__IO: "token:secret"
+  #
+  # Key derivation: dots → __, dashes → ___, uppercased, BUNDLE_ prefix.
+  # Value is "user:password" for HTTP Basic Auth.
+  class Credentials
+    def initialize
+      @registered = {} # "host" => "user:password"
+      @mutex = Thread::Mutex.new
+      @file_config = load_config_files
+    end
+
+    # Register credentials extracted from a URI with inline user:pass@host.
+    # Call from Gemfile/lockfile parsing so creds survive lockfile round-trips.
+    def register_uri(uri)
+      uri = URI.parse(uri.to_s) unless uri.is_a?(URI)
+      return unless uri.user
+
+      user = CGI.unescape(uri.user)
+      password = uri.password ? CGI.unescape(uri.password) : nil
+      auth = password ? "#{user}:#{password}" : user
+
+      @mutex.synchronize { @registered[uri.host] = auth }
+    end
+
+    # Scan an array of source hashes (from Gemfile parser) for inline creds.
+    def register_sources(sources)
+      sources.each do |src|
+        register_uri(src[:uri]) if src[:uri]
+      end
+    end
+
+    # Scan dependencies for source: options with inline creds.
+    def register_dependencies(dependencies)
+      dependencies.each do |dep|
+        src = dep.respond_to?(:source_options) ? dep.source_options[:source] : nil
+        register_uri(src) if src
+      end
+    end
+
+    # Scan lockfile source objects for remotes with inline creds.
+    def register_lockfile_sources(sources)
+      sources.each do |src|
+        if src.respond_to?(:remotes)
+          src.remotes.each { |r| register_uri(r) }
+        elsif src.respond_to?(:uri)
+          register_uri(src.uri)
+        end
+      end
+    end
+
+    # Returns [user, password] for the given URI, or nil.
+    def for_uri(uri)
+      uri = URI.parse(uri.to_s) unless uri.is_a?(URI)
+
+      # 1. Inline credentials in the URI itself
+      if uri.user
+        user = CGI.unescape(uri.user)
+        password = uri.password ? CGI.unescape(uri.password) : nil
+        return [user, password]
+      end
+
+      # 2–5. Registered + config files + env
+      auth = lookup_host(uri.host)
+      return nil unless auth
+
+      user, password = auth.split(":", 2)
+      [user, password]
+    end
+
+    # Apply Basic Auth to a Net::HTTP::Request if credentials exist.
+    def apply!(request, uri)
+      uri = URI.parse(uri.to_s) unless uri.is_a?(URI)
+      creds = for_uri(uri)
+      return unless creds
+
+      user, password = creds
+      request.basic_auth(user, password || "")
+    end
+
+    private
+
+    def lookup_host(host)
+      return nil unless host
+
+      # 2. Runtime-registered (from Gemfile inline URIs)
+      registered = @mutex.synchronize { @registered[host] }
+      return registered if registered
+
+      # 3–4. Config files (scint, then bundler)
+      key = self.class.key_for_host(host)
+      val = @file_config[key]
+      return val if val
+
+      # 5. Environment variable
+      ENV[key]
+    end
+
+    def load_config_files
+      config = {}
+      # Load in reverse priority (later overrides earlier)
+      load_yaml_into(config, bundler_config_path)
+      load_yaml_into(config, scint_credentials_path)
+      config
+    end
+
+    def load_yaml_into(config, path)
+      return unless path && File.exist?(path)
+
+      data = YAML.safe_load(File.read(path))
+      config.merge!(data) if data.is_a?(Hash)
+    rescue StandardError
+      # Ignore malformed files
+    end
+
+    def scint_credentials_path
+      xdg = ENV["XDG_CONFIG_HOME"] || File.join(Dir.home, ".config")
+      File.join(xdg, "scint", "credentials")
+    end
+
+    def bundler_config_path
+      File.join(Dir.home, ".bundle", "config")
+    end
+
+    # Convert "pkgs.shopify.io" → "BUNDLE_PKGS__SHOPIFY__IO"
+    def self.key_for_host(host)
+      key = host.to_s.dup
+      key.gsub!(".", "__")
+      key.gsub!("-", "___")
+      key.upcase!
+      "BUNDLE_#{key}"
+    end
+  end
+end

data/lib/scint/debug/io_trace.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+require "fileutils"
+require_relative "../fs"
+
+module Scint
+  module Debug
+    module IOTrace
+      module_function
+
+      @enabled = false
+      @log_io = nil
+      @log_path = nil
+      @mutex = Thread::Mutex.new
+      @patched = false
+      @patches = []
+
+      FILE_METHODS = %i[
+        open read binread write binwrite rename link symlink unlink delete
+        stat lstat exist? file? directory?
+      ].freeze
+
+      DIR_METHODS = %i[
+        glob children entries mkdir chdir exist?
+      ].freeze
+
+      PROCESS_METHODS = %i[spawn].freeze
+
+      KERNEL_METHODS = %i[system].freeze
+
+      def enable!(path)
+        expanded = File.expand_path(path)
+        FS.mkdir_p(File.dirname(expanded))
+
+        @mutex.synchronize do
+          disable_unlocked if @enabled
+          patch_methods!
+          # Start a fresh trace per run to avoid mixing data across installs.
+          @log_io = File.open(expanded, "w")
+          @log_path = expanded
+          @enabled = true
+        end
+
+        log("trace.start", path: expanded)
+        true
+      end
+
+      def disable!
+        @mutex.synchronize do
+          disable_unlocked
+          unpatch_methods!
+        end
+      end
+
+      def enabled?
+        @enabled
+      end
+
+      def log(op, **data)
+        return unless @enabled
+        return if Thread.current[:scint_iotrace_guard]
+
+        Thread.current[:scint_iotrace_guard] = true
+        begin
+          payload = {
+            ts: Time.now.utc.iso8601(6),
+            op: op,
+            pid: Process.pid,
+            tid: Thread.current.object_id,
+            data: sanitize(data),
+          }
+
+          loc = caller_locations(1, 8)&.find { |frame| frame.path && !frame.path.include?("io_trace.rb") }
+          payload[:loc] = "#{loc.path}:#{loc.lineno}" if loc
+
+          line = JSON.generate(payload)
+          @mutex.synchronize do
+            return unless @enabled && @log_io
+            @log_io.write(line)
+            @log_io.write("\n")
+            @log_io.flush
+          end
+        rescue StandardError
+          # Logging must never break install flow.
+        ensure
+          Thread.current[:scint_iotrace_guard] = false
+        end
+      end
+
+      def patch_methods!
+        return if @patched
+
+        patch_singleton_methods(File, FILE_METHODS, "File")
+        patch_singleton_methods(Dir, DIR_METHODS, "Dir")
+        patch_singleton_methods(Process, PROCESS_METHODS, "Process")
+        patch_instance_methods(Kernel, KERNEL_METHODS, "Kernel")
+
+        @patched = true
+      end
+
+      def unpatch_methods!
+        return unless @patched
+
+        @patches.reverse_each do |entry|
+          container = entry[:container]
+          method_name = entry[:method]
+          original_name = entry[:original]
+
+          next unless container.method_defined?(original_name) || container.private_method_defined?(original_name)
+
+          container.send(:alias_method, method_name, original_name)
+          container.send(:remove_method, original_name)
+
+          visibility = entry[:visibility]
+          container.send(visibility, method_name) if visibility
+        end
+
+        @patches.clear
+        @patched = false
+      end
+
+      def patch_singleton_methods(target, methods, prefix)
+        singleton = target.singleton_class
+
+        methods.each do |method_name|
+          next unless singleton.method_defined?(method_name) || singleton.private_method_defined?(method_name)
+
+          patch_method(singleton, method_name, "#{prefix}.#{method_name}")
+        end
+      end
+
+      def patch_instance_methods(mod, methods, prefix)
+        methods.each do |method_name|
+          next unless mod.method_defined?(method_name) || mod.private_method_defined?(method_name)
+
+          patch_method(mod, method_name, "#{prefix}.#{method_name}")
+        end
+      end
+
+      def patch_method(container, method_name, op_name)
+        original_name = "__scint_iotrace_orig_#{method_name}".to_sym
+        return if container.method_defined?(original_name) || container.private_method_defined?(original_name)
+
+        visibility = method_visibility(container, method_name)
+
+        container.send(:alias_method, original_name, method_name)
+        container.send(:define_method, method_name) do |*args, **kwargs, &block|
+          Scint::Debug::IOTrace.log(op_name, args: args, kwargs: kwargs)
+          if kwargs.empty?
+            send(original_name, *args, &block)
+          else
+            send(original_name, *args, **kwargs, &block)
+          end
+        end
+
+        container.send(visibility, method_name) if visibility
+
+        @patches << {
+          container: container,
+          method: method_name,
+          original: original_name,
+          visibility: visibility,
+        }
+      end
+
+      def method_visibility(container, method_name)
+        return :private if container.private_method_defined?(method_name)
+        return :protected if container.protected_method_defined?(method_name)
+        return :public if container.method_defined?(method_name)
+
+        nil
+      end
+
+      def disable_unlocked
+        return unless @enabled || @log_io
+
+        begin
+          if @enabled && @log_io
+            @log_io.write(JSON.generate({ ts: Time.now.utc.iso8601(6), op: "trace.stop", pid: Process.pid, tid: Thread.current.object_id }) + "\n")
+            @log_io.flush
+          end
+        rescue StandardError
+          nil
+        end
+
+        @enabled = false
+        io = @log_io
+        @log_io = nil
+        @log_path = nil
+        io&.close
+      end
+
+      def sanitize(value, depth = 0)
+        return "..." if depth > 3
+
+        case value
+        when String
+          value.length > 300 ? "#{value.byteslice(0, 300)}..." : value
+        when Symbol, Numeric, TrueClass, FalseClass, NilClass
+          value
+        when Array
+          value.first(10).map { |v| sanitize(v, depth + 1) }
+        when Hash
+          out = {}
+          value.each do |k, v|
+            out[sanitize(k, depth + 1)] = sanitize(v, depth + 1)
+            break if out.length >= 20
+          end
+          out
+        else
+          value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/scint/debug/sampler.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+require_relative "../fs"
+
+module Scint
+  module Debug
+    class Sampler
+      DEFAULT_HZ = 250
+      DEFAULT_MAX_DEPTH = 40
+
+      def initialize(path:, hz: DEFAULT_HZ, max_depth: DEFAULT_MAX_DEPTH)
+        @path = File.expand_path(path)
+        @hz = [hz.to_i, 1].max
+        @interval = 1.0 / @hz
+        @max_depth = [max_depth.to_i, 1].max
+
+        @mutex = Thread::Mutex.new
+        @thread = nil
+        @stop = false
+
+        @started_at_wall = nil
+        @started_at_mono = nil
+        @finished_at_wall = nil
+
+        @samples = 0
+        @stack_counts = Hash.new(0)
+        @frame_counts = Hash.new(0)
+        @sample_errors = 0
+      end
+
+      def start
+        return if @thread&.alive?
+
+        @started_at_wall = Time.now.utc
+        @started_at_mono = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        @stop = false
+
+        @thread = Thread.new do
+          loop do
+            break if stop?
+
+            sample_once
+            sleep(@interval)
+          end
+        rescue StandardError
+          @mutex.synchronize { @sample_errors += 1 }
+        end
+      end
+
+      def stop(exit_code: nil)
+        thread = nil
+        @mutex.synchronize do
+          @stop = true
+          thread = @thread
+        end
+        thread&.join
+
+        @finished_at_wall = Time.now.utc
+        write_report(exit_code: exit_code)
+      end
+
+      private
+
+      def stop?
+        @mutex.synchronize { @stop }
+      end
+
+      def sample_once
+        thread_snapshots = []
+
+        Thread.list.each do |thr|
+          next if thr == Thread.current
+          next unless thr.alive?
+
+          stack = thr.backtrace_locations
+          next if stack.nil? || stack.empty?
+
+          frames = stack.first(@max_depth).map { |loc| frame_string(loc) }
+          next if frames.empty?
+
+          thread_snapshots << frames
+        rescue StandardError
+          @mutex.synchronize { @sample_errors += 1 }
+        end
+
+        @mutex.synchronize do
+          thread_snapshots.each do |frames|
+            @samples += 1
+            @stack_counts[frames.join(";")] += 1
+            @frame_counts[frames.first] += 1
+          end
+        end
+      end
+
+      def frame_string(loc)
+        path = loc.path || "(unknown)"
+        "#{path}:#{loc.lineno}:in `#{loc.base_label}`"
+      end
+
+      def write_report(exit_code:)
+        finished_mono = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        started_mono = @started_at_mono || finished_mono
+        elapsed_ms = ((finished_mono - started_mono) * 1000.0).round
+
+        report = {
+          version: 1,
+          mode: "sampling",
+          sample_hz: @hz,
+          max_depth: @max_depth,
+          started_at: (@started_at_wall || Time.now.utc).iso8601(6),
+          finished_at: (@finished_at_wall || Time.now.utc).iso8601(6),
+          wall_ms: elapsed_ms,
+          exit_code: exit_code,
+          samples: @samples,
+          unique_stacks: @stack_counts.size,
+          sample_errors: @sample_errors,
+          top_frames: top_entries(@frame_counts, 50),
+          top_stacks: top_entries(@stack_counts, 200),
+          gc: {
+            count: GC.count,
+            total_allocated_objects: GC.stat(:total_allocated_objects),
+            heap_live_slots: GC.stat(:heap_live_slots),
+          },
+        }
+
+        FS.atomic_write(@path, JSON.pretty_generate(report))
+      end
+
+      def top_entries(hash, limit)
+        hash.sort_by { |_k, v| -v }.first(limit).map do |key, count|
+          { key: key, samples: count }
+        end
+      end
+    end
+  end
+end