scint 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2dfc2e1d04a71bb75faa5638b47b53c72449a3ebc857da9c83286ff4d5811ba2
+  data.tar.gz: c0e0375479b2dc2522289685583b13a5dd2637b94e5999557f1a32e31943ef7f
+SHA512:
+  metadata.gz: 54ede6af6c782642dee0fe66607830ddd78a7bda1e669e6d429188da2f0d0e97733cd014ddd80ce43c97cc9987296f699c9e274adfcef88ac7aa133369b42075
+  data.tar.gz: fb5bd293409889ddf8ce7ff16b61f51752528dc204340412f3aefca9f334221740be236fe3ba281c4325778645da03dd15a563aae101fbcaa5cbf07c91cca7a2

data/FEATURES.md

@@ -0,0 +1,13 @@
+- we want to download everything in parallel
+- ideally even git clones
+- we want git clones to come to us as fast as possible, we don't need all history
+- we want to bring inbound gems into a incoming directory for processing
+- we focus on creating a global cache that has all the gems perfectly prepared, we don't care about re-use between different versions there, and every ruby version/arch gets its own expanded cache
+- we attempt to do expensive operations in bulk such as mass unpacking of gems
+- we do everything in parallel that can be parallel
+- version number resolution works by casing the strings 1.1.1 into int64 at different orders of magnitude so that version comparisons are just int comparisons. 
+- final bundle install step is to bring all gems to ./.bundle in the most efficient operation imaginable
+- the installation process involves compilation. We attempt to have compilation happen while its not blocking other operations, but also only one compilation at a time
+- we have a book keeping object that governs the worker pools and that's present during each step (fetch, extract, compile, install) and recieves the tasks for each phase from the workers. 
+- i suspect that we need to fork of a worker for compilation which we then have to communicate with via some rpc format. simple "-> CALL method, <- RESULT:\n...." type line protocol through stdin/out might work well enough there. 
+

data/README.md

@@ -0,0 +1,216 @@
+# Scint
+
+Scint is an experimental Bundler/RubyGems replacement focused on high-throughput installs with a global cache and a fast local materialization step.
+
+It is written in pure Ruby with no dependencies; Ruby is plenty fast for this job.
+
+Scint is designed for full backwards compatibility with Bundler workflows:
+
+1. It reads `Gemfile` and `Gemfile.lock`.
+2. It writes standard `Gemfile.lock`.
+3. It interoperates with Bundler runtime layout. For example, `BUNDLE_PATH=".bundle" bundle exec ...` is expected to work.
+4. The intent is identical behavior with better install and execution throughput.
+
+The core idea is:
+
+1. Prepare artifacts once in a global cache (`~/.cache/scint`).
+2. Materialize project-local runtime state into `.bundle/` as efficiently as possible (hardlinks where possible).
+3. Execute work in explicit concurrent phases coordinated by a scheduler session.
+
+## Why Scint
+
+`scint` comes from *scintillation*: short, high-energy flashes rather than continuous glow.
+
+That maps directly to the runtime model:
+
+1. Event-driven scheduling.
+2. Burst parallelism where safe.
+3. Tight phase boundaries with clear handoffs.
+
+## CLI
+
+```bash
+scint install
+scint exec <command>
+scint cache list
+scint cache clear
+scint cache dir
+```
+
+Performance and IO diagnostics:
+
+```bash
+# Ruby sampling profile (JSON)
+SCINT_PROFILE=/tmp/scint-profile.json SCINT_PROFILE_HZ=400 scint install --force
+
+# Ruby-level IO trace (JSONL)
+SCINT_IO_TRACE=/tmp/scint-io.jsonl scint install --force
+
+# Summarize high-volume IO operations for quick LLM review
+scint-io-summary /tmp/scint-io.jsonl
+
+# Syscall-level trace (Linux strace / macOS dtruss)
+scint-syscall-trace /tmp/scint-sys.log -- scint install --force
+```
+
+Compatibility example:
+
+```bash
+BUNDLE_PATH=".bundle" bundle exec ruby -v
+```
+
+Defaults:
+
+1. Local install/runtime directory: `.bundle/`
+2. Global cache root: `~/.cache/scint` (or `XDG_CACHE_HOME`)
+
+## Install Architecture
+
+Scint install is phase-oriented. Each phase has explicit responsibilities and feeds the next phase.
+
+1. Parse inputs (`Gemfile`, optional `Gemfile.lock`)
+2. Fetch source metadata (indexes, git clones)
+3. Resolve dependency graph
+4. Plan actions (`skip`, `link`, `download`, `build_ext`)
+5. Download/extract/cache artifacts
+6. Link into local `.bundle` runtime
+7. Build native extensions after link phase is ready
+8. Write outputs (`Gemfile.lock`, runtime lock, warnings/summary)
+
+```mermaid
+flowchart LR
+    A[Gemfile + Gemfile.lock] --> B[Parse + Source Discovery]
+    B --> C[Fetch Indexes / Clone Git]
+    C --> D[Resolve Graph]
+    D --> E[Planner]
+    E -->|skip| F[Already Installed]
+    E -->|link| G[Link from Extracted Cache]
+    E -->|download| H[Download .gem]
+    H --> I[Extract + Cache Metadata]
+    I --> G
+    G --> J[All Links Complete]
+    J --> K[Native Extension Build]
+    K --> L[Runtime + Lockfile Write]
+    L --> M[Done]
+
+    subgraph GlobalCache["Global Cache (~/.cache/scint)"]
+      H
+      I
+    end
+
+    subgraph ProjectRuntime["Project Runtime (.bundle)"]
+      G
+      K
+      L
+    end
+```
+
+## Scheduler as Session Object
+
+The `Scheduler` is more than a queue: it is the install *session object*.
+It owns global execution state and coordinates workers with phase-aware semantics.
+
+The scheduler tracks:
+
+1. Job graph and dependencies
+2. Priority classes by job type
+3. Worker pool scaling
+4. Job state transitions (`pending`, `running`, `completed`, `failed`)
+5. Follow-up chaining (for phase handoff)
+6. Fail-fast abort state and error collection
+7. Progress/stats snapshots used by reporting
+
+Workers do not own global install strategy. They execute task payloads with context supplied by scheduler enqueuing and phase sequencing.
+
+```mermaid
+sequenceDiagram
+    participant U as User
+    participant C as scint install
+    participant S as Scheduler(Session)
+    participant W as WorkerPool
+    participant T as Task Worker
+
+    U->>C: scint install
+    C->>S: start(max_workers, fail_fast)
+    C->>S: enqueue(fetch_index/git/...)
+    S->>W: dispatch ready jobs
+    W->>T: execute payload
+    T-->>S: complete/fail + result
+    S-->>C: wait_for phase completion
+    C->>S: enqueue next phase (download/link/build_ext)
+    S-->>C: stats + errors + aborted?
+    C-->>U: summary + lockfile/runtime outputs
+```
+
+## Job Lifecycle
+
+```mermaid
+stateDiagram-v2
+    [*] --> pending
+    pending --> running: dependencies satisfied + worker slot available
+    running --> completed: success
+    running --> failed: exception / command failure
+    completed --> [*]
+    failed --> [*]
+```
+
+## Data Layout
+
+Global cache (`~/.cache/scint`):
+
+1. `inbound/` downloaded gem files
+2. `extracted/` unpacked gem trees
+3. `ext/` compiled extension cache keyed by ABI
+4. `index/` source metadata/index cache
+5. `git/` cached git repositories
+
+Project-local runtime (`.bundle/`):
+
+1. `ruby/<major.minor.0>/gems/` linked gem trees
+2. `ruby/<major.minor.0>/specifications/` gemspecs
+3. `ruby/<major.minor.0>/bin/` gem binstubs
+4. `bin/` project-level wrappers
+5. `scint.lock.marshal` runtime lock for `scint exec`
+
+## Concurrency Model
+
+Scint parallelizes all non-conflicting work aggressively:
+
+1. Index fetch and git clone start early.
+2. Downloads can chain follow-up link tasks.
+3. Planner ordering prioritizes large downloads first to keep pipeline saturated.
+4. Build-ext runs after link readiness to make dependencies visible.
+5. Fail-fast mode aborts scheduling of new work after the first hard failure.
+
+## Error Model
+
+Scint is designed to be explicit on failure:
+
+1. Install exits non-zero on failures.
+2. Native build failures include full captured command output.
+3. Final summary reports installed/failed/skipped counts.
+4. `.gitignore` warning is emitted when `.bundle/` is not ignored.
+
+## `scint exec` Runtime
+
+`scint exec` sets runtime env and load paths from `scint.lock.marshal`, then `exec`s the target command.
+
+Key behaviors:
+
+1. Injects runtime load paths and bundler compatibility shim.
+2. Sets `GEM_HOME`/`GEM_PATH` to the local `.bundle` runtime.
+3. Prefers local `.bundle/bin` executables.
+4. Rebuilds runtime lock from `Gemfile.lock` + installed gems when possible if missing.
+
+## Aspirational Direction
+
+The current architecture already separates phases and scheduling concerns. Planned direction is to make this even more explicit:
+
+1. First-class session object API around scheduler state and phase transitions.
+2. Isolated compile worker process with a simple line-protocol RPC (`CALL` / `RESULT`) for stronger fault isolation.
+3. More deterministic bulk operations for extraction/linking.
+4. Better per-phase telemetry for latency and saturation analysis.
+
+## Status
+
+Scint is experimental and optimized for architecture iteration speed. Behavior and internals may change quickly.

data/bin/bundler-vs-scint

@@ -0,0 +1,233 @@
+#!/usr/bin/env bash
+# Benchmark: stock bundler vs scint, cold and warm caches.
+#
+# Cold = fresh install dir, no caches.
+# Warm = fresh install dir, but gem download caches are warm from the cold run.
+#
+# No copying needed — warm runs just get a new BUNDLE_PATH while keeping
+# the same GEM_HOME / GEM_PATH / global cache so downloads are already cached.
+#
+# Creates an isolated tmp directory for all outputs. Clean up with:
+#   rm -rf /tmp/scint-bench-*
+#
+# Usage: ./bin/bundler-vs-scint [/path/to/project]
+#   Default project: /Users/tobi/src/github.com/Shopify/u2
+
+set -euo pipefail
+
+PROJECT="${1:-/Users/tobi/src/github.com/Shopify/u2}"
+SCINT_BIN="$(cd "$(dirname "$0")/.." && pwd)/bin/scint"
+TMPROOT=$(mktemp -d /tmp/scint-bench-XXXXXX)
+
+# Each run gets its own BUNDLE_PATH (install destination).
+# GEM_HOME/GEM_PATH stay shared so download caches persist between cold→warm.
+# Scint uses XDG_CACHE_HOME for its global cache — redirect to tmpdir.
+BUNDLER_COLD="$TMPROOT/bundler-cold"
+BUNDLER_WARM="$TMPROOT/bundler-warm"
+BUNDLER_GEM_HOME="$TMPROOT/bundler-gem-home"
+SCINT_COLD="$TMPROOT/scint-cold"
+SCINT_WARM="$TMPROOT/scint-warm"
+SCINT_GEM_HOME="$TMPROOT/scint-gem-home"
+SCINT_XDG_CACHE="$TMPROOT/scint-cache"
+LOGS="$TMPROOT/logs"
+mkdir -p "$BUNDLER_COLD" "$BUNDLER_WARM" "$BUNDLER_GEM_HOME" \
+         "$SCINT_COLD" "$SCINT_WARM" "$SCINT_GEM_HOME" "$SCINT_XDG_CACHE" "$LOGS"
+
+echo "=== Benchmark: bundler vs scint ==="
+echo "Project:  $PROJECT"
+echo "Tmp root: $TMPROOT"
+echo ""
+
+# Helper: time a command, capture output, return elapsed seconds
+run_timed() {
+  local label="$1"
+  local logfile="$2"
+  shift 2
+
+  echo "--- $label ---"
+  local start end_time elapsed
+  start=$(ruby -e 'puts Process.clock_gettime(Process::CLOCK_MONOTONIC)')
+
+  # Run in the project directory, tee to both log and stdout
+  (cd "$PROJECT" && "$@") 2>&1 | tee "$logfile" || true
+
+  end_time=$(ruby -e 'puts Process.clock_gettime(Process::CLOCK_MONOTONIC)')
+  elapsed=$(ruby -e "puts (($end_time - $start)).round(2)")
+  echo "  Elapsed: ${elapsed}s (log: $logfile)"
+  echo "$elapsed" > "${logfile}.time"
+}
+
+# ── 1. Cold bundler ──────────────────────────────────────────────
+echo ""
+echo "════════════════════════════════════════"
+echo " 1/4  Bundler (cold)"
+echo "════════════════════════════════════════"
+SYSTEM_GEM_DIR="$(ruby -e 'puts Gem.default_dir')"
+run_timed "bundler install (cold)" "$LOGS/bundler-cold.log" \
+  env BUNDLE_PATH="$BUNDLER_COLD" \
+      GEM_HOME="$BUNDLER_GEM_HOME" \
+      GEM_PATH="$BUNDLER_GEM_HOME:$SYSTEM_GEM_DIR" \
+      BUNDLE_DISABLE_SHARED_GEMS=1 \
+  bundle install --jobs=8
+
+# ── 2. Warm bundler (new install dir, same gem cache) ────────────
+echo ""
+echo "════════════════════════════════════════"
+echo " 2/4  Bundler (warm)"
+echo "════════════════════════════════════════"
+run_timed "bundler install (warm)" "$LOGS/bundler-warm.log" \
+  env BUNDLE_PATH="$BUNDLER_WARM" \
+      GEM_HOME="$BUNDLER_GEM_HOME" \
+      GEM_PATH="$BUNDLER_GEM_HOME:$SYSTEM_GEM_DIR" \
+      BUNDLE_DISABLE_SHARED_GEMS=1 \
+  bundle install --jobs=8
+
+# ── 3. Cold scint ────────────────────────────────────────────────
+echo ""
+echo "════════════════════════════════════════"
+echo " 3/4  Scint (cold)"
+echo "════════════════════════════════════════"
+run_timed "scint install (cold)" "$LOGS/scint-cold.log" \
+  env BUNDLE_PATH="$SCINT_COLD" \
+      GEM_HOME="$SCINT_GEM_HOME" \
+      GEM_PATH="$SCINT_GEM_HOME:$SYSTEM_GEM_DIR" \
+      XDG_CACHE_HOME="$SCINT_XDG_CACHE" \
+  "$SCINT_BIN" install --path "$SCINT_COLD"
+
+# ── 4. Warm scint (new install dir, global cache already warm) ───
+echo ""
+echo "════════════════════════════════════════"
+echo " 4/4  Scint (warm)"
+echo "════════════════════════════════════════"
+run_timed "scint install (warm)" "$LOGS/scint-warm.log" \
+  env BUNDLE_PATH="$SCINT_WARM" \
+      GEM_HOME="$SCINT_GEM_HOME" \
+      GEM_PATH="$SCINT_GEM_HOME:$SYSTEM_GEM_DIR" \
+      XDG_CACHE_HOME="$SCINT_XDG_CACHE" \
+  "$SCINT_BIN" install --path "$SCINT_WARM"
+
+# ── Summary ──────────────────────────────────────────────────────
+echo ""
+echo "════════════════════════════════════════"
+echo " Results"
+echo "════════════════════════════════════════"
+
+bc=$(cat "$LOGS/bundler-cold.log.time")
+bw=$(cat "$LOGS/bundler-warm.log.time")
+sc=$(cat "$LOGS/scint-cold.log.time")
+sw=$(cat "$LOGS/scint-warm.log.time")
+
+printf "  %-20s %8ss\n" "Bundler (cold):" "$bc"
+printf "  %-20s %8ss\n" "Bundler (warm):" "$bw"
+printf "  %-20s %8ss\n" "Scint (cold):" "$sc"
+printf "  %-20s %8ss\n" "Scint (warm):" "$sw"
+echo ""
+
+cold_speedup=$(ruby -e "puts ($bc.to_f / $sc.to_f).round(1)")
+warm_speedup=$(ruby -e "puts ($bw.to_f / $sw.to_f).round(1)")
+echo "  Cold speedup: ${cold_speedup}x"
+echo "  Warm speedup: ${warm_speedup}x"
+
+# ── Directory comparison ─────────────────────────────────────────
+echo ""
+echo "════════════════════════════════════════"
+echo " Directory comparison"
+echo "════════════════════════════════════════"
+
+DIFF_LOG="$LOGS/diff-report.txt"
+> "$DIFF_LOG"
+
+# Compare installed gem directories
+bundler_gems="$BUNDLER_COLD/ruby/3.4.0/gems"
+scint_gems="$SCINT_COLD/ruby/3.4.0/gems"
+
+if [[ -d "$bundler_gems" && -d "$scint_gems" ]]; then
+  # Gem directories present in each
+  bundler_gem_list=$(cd "$bundler_gems" && ls -1 | sort)
+  scint_gem_list=$(cd "$scint_gems" && ls -1 | sort)
+
+  only_bundler=$(comm -23 <(echo "$bundler_gem_list") <(echo "$scint_gem_list"))
+  only_scint=$(comm -13 <(echo "$bundler_gem_list") <(echo "$scint_gem_list"))
+  in_both=$(comm -12 <(echo "$bundler_gem_list") <(echo "$scint_gem_list"))
+
+  bundler_count=$(echo "$bundler_gem_list" | wc -l | tr -d ' ')
+  scint_count=$(echo "$scint_gem_list" | wc -l | tr -d ' ')
+  both_count=$(echo "$in_both" | wc -l | tr -d ' ')
+
+  echo "  Bundler gems: $bundler_count"
+  echo "  Scint gems:   $scint_count"
+  echo "  In common:    $both_count"
+
+  if [[ -n "$only_bundler" ]]; then
+    echo ""
+    echo "  Only in bundler:"
+    echo "$only_bundler" | sed 's/^/    /'
+  fi
+
+  if [[ -n "$only_scint" ]]; then
+    echo ""
+    echo "  Only in scint:"
+    echo "$only_scint" | sed 's/^/    /'
+  fi
+
+  # Compare gemspec counts
+  bundler_specs="$BUNDLER_COLD/ruby/3.4.0/specifications"
+  scint_specs="$SCINT_COLD/ruby/3.4.0/specifications"
+  if [[ -d "$bundler_specs" && -d "$scint_specs" ]]; then
+    bs_count=$(ls -1 "$bundler_specs" | wc -l | tr -d ' ')
+    ss_count=$(ls -1 "$scint_specs" | wc -l | tr -d ' ')
+    echo ""
+    echo "  Bundler gemspecs: $bs_count"
+    echo "  Scint gemspecs:   $ss_count"
+  fi
+
+  # Compare bin directories
+  bundler_bin="$BUNDLER_COLD/ruby/3.4.0/bin"
+  scint_bin_dir="$SCINT_COLD/ruby/3.4.0/bin"
+  if [[ -d "$bundler_bin" && -d "$scint_bin_dir" ]]; then
+    bb_count=$(ls -1 "$bundler_bin" | wc -l | tr -d ' ')
+    sb_count=$(ls -1 "$scint_bin_dir" | wc -l | tr -d ' ')
+    echo ""
+    echo "  Bundler bins: $bb_count"
+    echo "  Scint bins:   $sb_count"
+
+    only_b_bins=$(comm -23 <(ls -1 "$bundler_bin" | sort) <(ls -1 "$scint_bin_dir" | sort))
+    only_s_bins=$(comm -13 <(ls -1 "$bundler_bin" | sort) <(ls -1 "$scint_bin_dir" | sort))
+    if [[ -n "$only_b_bins" ]]; then
+      echo "  Bins only in bundler:"
+      echo "$only_b_bins" | sed 's/^/    /'
+    fi
+    if [[ -n "$only_s_bins" ]]; then
+      echo "  Bins only in scint:"
+      echo "$only_s_bins" | sed 's/^/    /'
+    fi
+  fi
+
+  # Check a few random gems for file count differences
+  echo ""
+  echo "  File count spot-check (first 10 shared gems):"
+  echo "$in_both" | head -10 | while read -r gem; do
+    bf=$(find "$bundler_gems/$gem" -type f 2>/dev/null | wc -l | tr -d ' ')
+    sf=$(find "$scint_gems/$gem" -type f 2>/dev/null | wc -l | tr -d ' ')
+    if [[ "$bf" != "$sf" ]]; then
+      echo "    $gem: bundler=$bf scint=$sf  ← DIFF"
+    else
+      echo "    $gem: $bf files ✓"
+    fi
+  done
+
+  # Disk size comparison
+  echo ""
+  bundler_size=$(du -sh "$BUNDLER_COLD" 2>/dev/null | cut -f1)
+  scint_size=$(du -sh "$SCINT_COLD" 2>/dev/null | cut -f1)
+  echo "  Bundler total size: $bundler_size"
+  echo "  Scint total size:   $scint_size"
+else
+  echo "  ⚠ Could not find gem directories to compare"
+  echo "  Bundler: $bundler_gems (exists: $(test -d "$bundler_gems" && echo yes || echo no))"
+  echo "  Scint:   $scint_gems (exists: $(test -d "$scint_gems" && echo yes || echo no))"
+fi
+
+echo ""
+echo "All logs and data in: $TMPROOT"
+echo "Clean up: rm -rf $TMPROOT"

data/bin/scint

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Ensure lib is on the load path
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+
+require "scint"
+
+if ENV["SCINT_IO_TRACE"] && !ENV["SCINT_IO_TRACE"].empty?
+  require "scint/debug/io_trace"
+  Scint::Debug::IOTrace.enable!(ENV["SCINT_IO_TRACE"])
+end
+
+profiler = nil
+if ENV["SCINT_PROFILE"] && !ENV["SCINT_PROFILE"].empty?
+  require "scint/debug/sampler"
+  hz = ENV.fetch("SCINT_PROFILE_HZ", "250").to_i
+  depth = ENV.fetch("SCINT_PROFILE_DEPTH", "40").to_i
+  profiler = Scint::Debug::Sampler.new(path: ENV["SCINT_PROFILE"], hz: hz, max_depth: depth)
+  profiler.start
+end
+
+require "scint/cli"
+
+exit_code = 1
+begin
+  exit_code = Scint::CLI.run(ARGV)
+ensure
+  profiler&.stop(exit_code: exit_code)
+  if defined?(Scint::Debug::IOTrace)
+    Scint::Debug::IOTrace.disable!
+  end
+end
+
+exit(exit_code)

data/bin/scint-io-summary

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "json"
+
+path = ARGV[0]
+unless path && !path.empty?
+  warn "Usage: scint-io-summary TRACE.jsonl"
+  exit 2
+end
+
+op_counts = Hash.new(0)
+op_path_counts = Hash.new(0)
+line_count = 0
+
+File.foreach(path) do |line|
+  begin
+    row = JSON.parse(line)
+  rescue JSON::ParserError
+    next
+  end
+
+  line_count += 1
+  op = row["op"] || "(unknown)"
+  op_counts[op] += 1
+
+  args = row.dig("data", "args")
+  first_arg = args.is_a?(Array) ? args[0] : nil
+  if first_arg.is_a?(String) && !first_arg.empty?
+    op_path_counts[[op, first_arg]] += 1
+  end
+end
+
+puts "trace_file=#{path}"
+puts "total_rows=#{line_count}"
+puts
+puts "Top operations:"
+op_counts.sort_by { |_k, v| -v }.first(30).each do |op, count|
+  puts "#{count}\t#{op}"
+end
+
+puts
+puts "Top repeated op+path:"
+op_path_counts.sort_by { |_k, v| -v }.first(50).each do |(op, p), count|
+  puts "#{count}\t#{op}\t#{p}"
+end

data/bin/scint-syscall-trace

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "rbconfig"
+
+def usage
+  warn "Usage: scint-syscall-trace LOGFILE -- CMD [ARGS...]"
+  warn "Example: scint-syscall-trace /tmp/scint-sys.log -- scint install"
+  exit 2
+end
+
+sep = ARGV.index("--")
+usage unless sep && sep.positive?
+
+logfile = ARGV[0]
+cmd = ARGV[(sep + 1)..]
+usage if logfile.nil? || logfile.empty? || cmd.nil? || cmd.empty?
+
+if system("command -v strace >/dev/null 2>&1")
+  exec("strace", "-ff", "-tt", "-s", "256", "-e", "trace=file,process", "-o", logfile, *cmd)
+end
+
+if system("command -v dtruss >/dev/null 2>&1")
+  if Process.uid != 0
+    warn "dtruss usually requires root on macOS. Re-run with sudo:"
+    warn "  sudo #{File.expand_path($PROGRAM_NAME)} #{logfile} -- #{cmd.join(" ")}"
+    exit 2
+  end
+
+  exec(
+    "dtruss",
+    "-f",
+    "-t", "open,open_nocancel,stat64,lstat64,access,rename,unlink,mkdir,rmdir,read,write,pread,pwrite,clonefile",
+    "-o", logfile,
+    "--",
+    *cmd
+  )
+end
+
+warn "No supported syscall tracer found (expected strace or dtruss)."
+exit 2

data/lib/bundler/setup.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "../bundler"
+
+Bundler.setup