rubik 0.1.6 → 0.2.0

data/lib/rubik/concurrency/event_loop.rb

@@ -20,7 +20,8 @@ module Rubik
     #     the loop thread wakes immediately.
     #   * Wake staleness is handled by park generations: every registration
     #     stamps @gen[fiber]; timer fires and io dispatch only push when the
-    #     generation still matches, so a fiber that timed out and re-parked
+    #     generation still matches at dispatch, including queued wakeups,
+    #     so a fiber that timed out and re-parked
     #     elsewhere can never be resumed by a stale source.
     #
     # Drain model (waiters, not liveness — Fiber#alive? does not exist on
@@ -48,8 +49,8 @@ module Rubik
 
       def initialize
         @mutex = ::Mutex.new
-        @runnable = []       # [[fiber, resume_value]] — guarded by @mutex
-        @parked = {}         # fiber => true (block-hook parks) — guarded
+        @runnable = []       # [[fiber, resume_value, park_generation]] — guarded by @mutex
+        @parked = {}         # fiber => generation (block-hook parks) — guarded
         @waiter_threads = [] # process-wait threads — guarded
         # Stale timers (fiber re-parked or resumed since registration) must
         # not gate draining — @gen is bumped on every resume, so any of this
@@ -77,11 +78,11 @@ module Rubik
 
       # Queues a fiber to be resumed with value. Safe from foreign threads:
       # pushes write a self-pipe byte so the loop's IO.select wakes at once.
-      def push(fiber, value: true)
+      def push(fiber, value: true, generation: nil)
         @mutex.synchronize do
           return if @closed
 
-          @runnable << [fiber, value]
+          @runnable << [fiber, value, generation]
         end
         kick unless ::Thread.current.equal?(@loop_thread)
       end
@@ -95,8 +96,8 @@ module Rubik
         @mutex.synchronize do
           return if @closed
 
-          @parked.delete(fiber)
-          @runnable << [fiber, value]
+          generation = @parked.delete(fiber)
+          @runnable << [fiber, value, generation]
         end
         kick unless ::Thread.current.equal?(@loop_thread)
       end
@@ -149,8 +150,8 @@ module Rubik
       # timeout of 0 still registers a timer (fires immediately) — truthiness
       # guards would park join(0)/wait(0) polls forever.
       def park(_blocker, timeout = nil)
-        @mutex.synchronize { @parked[::Fiber.current] = true }
         value = park_fiber do |fiber, gen|
+          @mutex.synchronize { @parked[fiber] = gen }
           @timers.add(monotonic + timeout, fiber, :timeout, gen) unless timeout.nil?
         end
         value == :timeout ? false : value
@@ -172,49 +173,52 @@ module Rubik
         value
       end
 
-      # io_read body (one nonblocking attempt per call — the VM re-invokes
-      # the hook in a loop, mirroring IO::Buffer#read's one-syscall shape).
-      # Fills the caller's buffer and returns bytes read (0 = EOF).
-      #
-      # Two 4.0.6 facts shape this (verified by probe): the integer hook
-      # args are protocol noise (3.3 passes length; 4.0 passes 0,0 — both
-      # size the buffer to the requested read, hence buffer.size), and
-      # EVERY blocking-family read primitive — read_nonblock included — is
-      # itself routed back through scheduler.io_read once the hook exists.
-      # The Fiber.blocking wrap is the VM-sanctioned escape (ruby's own test
-      # scheduler wraps its primitives the same way): it runs the primitive
-      # immediately, bypassing interception, and read_nonblock(exception:
-      # false) never blocks the OS thread.
-      def read_io(io, buffer)
-        length = buffer.size
-        return 0 if length.zero?
+      # A zero minimum means one nonblocking attempt: return -errno to
+      # the VM instead of parking here, so read_nonblock preserves the
+      # caller's subsequent IO#wait_readable deadline (e.g. Net::HTTP).
+      # Fiber.blocking prevents the primitive from re-entering this hook.
+      def read_io(io, buffer, minimum = 0, offset = 0)
+        transferred = 0
+        capacity = buffer.size - offset
+        return 0 if capacity.zero?
 
         loop do
-          chunk = ::Fiber.blocking { io.read_nonblock(length, exception: false) }
+          chunk = ::Fiber.blocking { io.read_nonblock(capacity - transferred, exception: false) }
           case chunk
-          when :wait_readable then wait_io(io, READABLE, nil)
-          when :wait_writable then wait_io(io, WRITABLE, nil)
-          when nil then return 0
+          when :wait_readable, :wait_writable
+            return transferred.positive? ? transferred : -Errno::EAGAIN::Errno if transferred >= minimum
+
+            wait_io(io, chunk == :wait_readable ? READABLE : WRITABLE, nil)
+          when nil then return transferred
           else
-            buffer.copy(::IO::Buffer.for(chunk), 0)
-            return chunk.bytesize
+            buffer.set_string(chunk, offset + transferred)
+            transferred += chunk.bytesize
+            return transferred if transferred >= minimum || transferred == capacity
           end
         end
+      rescue SystemCallError => e
+        -e.errno
       end
 
-      # io_write body: writes the whole caller-supplied buffer with one
-      # nonblocking attempt per call, parking on WRITABLE between attempts.
-      # (4.0.6 passes (0,0) as integers and expects the full buffer out.)
-      def write_io(io, buffer)
-        data = buffer.get_string(0, buffer.size)
-        return 0 if data.empty?
+      def write_io(io, buffer, minimum = 0, offset = 0)
+        transferred = 0
+        capacity = buffer.size - offset
+        return 0 if capacity.zero?
 
         loop do
+          data = buffer.get_string(offset + transferred, capacity - transferred)
           written = ::Fiber.blocking { io.write_nonblock(data, exception: false) }
-          return written if written.is_a?(::Integer)
+          if written.is_a?(::Integer)
+            transferred += written
+            return transferred if transferred >= minimum || transferred == capacity
+          else
+            return transferred.positive? ? transferred : -Errno::EAGAIN::Errno if transferred >= minimum
 
-          wait_io(io, WRITABLE, nil)
+            wait_io(io, written == :wait_readable ? READABLE : WRITABLE, nil)
+          end
         end
+      rescue SystemCallError => e
+        -e.errno
       end
 
       # DNS resolution parks the fiber; the DnsPool worker delivers the list
@@ -345,7 +349,9 @@ module Rubik
 
       def run_batch
         while (item = @mutex.synchronize { @runnable.shift })
-          fiber, value = item
+          fiber, value, generation = item
+          next if generation && @gen[fiber] != generation
+
           # A resumed fiber is definitionally no longer parked; dropping the
           # registration here keeps interrupt-style wakes from leaking parks.
           # Bumping the park generation invalidates every OTHER outstanding
@@ -369,7 +375,9 @@ module Rubik
       end
 
       def select_or_wait
-        read_set = @io_waiters.keys
+        read_set = @io_waiters.each_with_object([]) do |(io, slot), acc|
+          acc << io unless slot[:read].empty?
+        end
         write_set = @io_waiters.each_with_object([]) do |(io, slot), acc|
           acc << io unless slot[:write].empty?
         end
@@ -407,7 +415,7 @@ module Rubik
           next if gen != STICKY && @gen[fiber] != gen # stale: fiber moved on after registering
 
           drop_io_interest(fiber)
-          push(fiber, value: value)
+          push(fiber, value: value, generation: gen == STICKY ? nil : gen)
         end
       end
 
@@ -420,7 +428,9 @@ module Rubik
         slot = @io_waiters[io]
         return unless slot
 
-        waiters = slot[:read].merge(slot[:write])
+        waiters = {}
+        waiters.merge!(slot[:read]) if events.anybits?(READABLE)
+        waiters.merge!(slot[:write]) if events.anybits?(WRITABLE)
         waiters.each do |fiber, gen|
           if @gen[fiber] != gen
             # Stale interest (the fiber timed out or moved on): remove it so
@@ -434,7 +444,7 @@ module Rubik
           # it re-registers with a fresh generation.
           slot[:read].delete(fiber)
           slot[:write].delete(fiber)
-          push(fiber, value: events)
+          push(fiber, value: events, generation: gen)
         end
         @io_waiters.delete(io) if slot[:read].empty? && slot[:write].empty?
       end
@@ -460,7 +470,9 @@ module Rubik
           slot = @io_waiters.delete(io)
           next unless slot
 
-          (slot[:read].keys + slot[:write].keys).each { |fiber| push(fiber, value: 0) }
+          slot[:read].merge(slot[:write]).each do |fiber, gen|
+            push(fiber, value: 0, generation: gen)
+          end
           pruned += 1
         end
         pruned

data/lib/rubik/concurrency/scheduler.rb

@@ -5,23 +5,9 @@ require_relative "process_waiter"
 
 module Rubik
   module Concurrency
-    # Adapter for the VM's Fiber::Scheduler hook protocol — stateless; all
-    # state lives on the EventLoop. Ruby 3.3 ↔ 4.0 protocol drift is
-    # concentrated here (probes against 4.0.6, plan §2):
-    #
-    #   fiber    4.0: fiber(&blk) — scheduler creates and returns the fiber.
-    #            3.3: fiber(fiber, block) — VM pre-created it.
-    #   io_read  integer args differ (3.3 passes length; 4.0 passes 0, 0)
-    #   io_write but the buffer is always sized to the operation, so both
-    #            hooks drive off buffer.size — see EventLoop#read_io.
-    #
-    # io_read/io_write are required on 4.0: without them a plain IO#read
-    # inside a scheduled fiber falls back to a whole-thread BLOCKING read
-    # (measured: 20 × 0.2 s child pipes serialized into 13 s). The buffer is
-    # filled/drained with read_nonblock/write_nonblock + IO::Buffer views —
-    # IO#nonblock= and IO::Buffer#read(io,...) are NOT usable on Windows
-    # builds (NoMethodError / constant-zero reads, verified), while the
-    # nonblock(…, exception: false) family works for pipes and sockets alike.
+    # Adapter for the VM's Fiber::Scheduler hooks. IO hooks receive a
+    # minimum transfer length and a buffer offset. A zero minimum requests
+    # one nonblocking attempt; the VM owns subsequent waits and deadlines.
     class Scheduler
       attr_reader :loop
 
@@ -42,15 +28,12 @@ module Rubik
         @loop.wait_io(io, events, timeout)
       end
 
-      # The integer args differ per protocol (3.3: length; 4.0. offset/length
-      # both zero) but the buffer is always sized to the operation, so the
-      # EventLoop drives both hooks off buffer.size — see read_io/write_io.
-      def io_read(io, buffer, *_protocol_args)
-        @loop.read_io(io, buffer)
+      def io_read(io, buffer, length, offset = 0)
+        @loop.read_io(io, buffer, length, offset)
       end
 
-      def io_write(io, buffer, *_protocol_args)
-        @loop.write_io(io, buffer)
+      def io_write(io, buffer, length, offset = 0)
+        @loop.write_io(io, buffer, length, offset)
       end
 
       def kernel_sleep(duration = nil)

data/lib/rubik/context/git_lister.rb

@@ -21,7 +21,12 @@ module Rubik
         )
         return nil unless status.success?
 
-        out.split("\x00", -1).reject(&:empty?).map { |p| p.tr("\\", "/") }.uniq
+        # PERF: NUL-split with conditional in-place backslash translation and
+        # in-place deduplication avoids intermediate array and string allocations.
+        res = out.split("\x00", -1).reject(&:empty?)
+        res.map! { |p| p.tr("\\", "/") } if out.include?("\\")
+        res.uniq!
+        res
       rescue StandardError
         nil
       end

data/lib/rubik/context/scanner.rb

@@ -196,8 +196,9 @@ module Rubik
         }
       end
 
+      # PERF: integer math avoids Rational allocation from Time#to_r (~5x faster, zero allocation)
       def mtime_micros(stat)
-        (stat.mtime.to_r * 1_000_000).to_i
+        (stat.mtime.tv_sec * 1_000_000) + stat.mtime.tv_usec
       end
 
       def walk_dir(base_dir, rel_prefix, key_prefix, ignore_patterns, previous, needles)
@@ -325,6 +326,15 @@ module Rubik
         # depth. subtree_ignored? is a pure function of (dir, needles), so
         # the memo is exact.
         dir_verdicts = Hash.new { |h, dir| h[dir] = subtree_ignored?(dir, needles) }
+
+        # PERF: filter ignore_patterns to exclude prunable subtree patterns that
+        # dir_verdicts already checked on ancestor directory segments.
+        file_patterns = ignore_patterns.reject do |pat|
+          m = PRUNABLE_PATTERN.match(pat)
+          m && !m[1].include?("*") && !m[1].include?("?") && !m[1].include?("[")
+        end
+        file_rules = compile_ignore_regexes(file_patterns)
+
         order_like_walker(rel_paths).each do |rel|
           # PERF: zero-allocation ancestor check using string slicing instead of Array#split and Array#join
           ignored_dir = false
@@ -337,7 +347,8 @@ module Rubik
             idx += 1
           end
           next if ignored_dir
-          next if ignored?(rel, ignore_patterns)
+          next if rel == ".rubik" || rel.start_with?(".rubik/") || rel == ".git" || rel.start_with?(".git/")
+          next if file_rules.any? { |r| pattern_match?(r, rel) }
           next unless included?(rel, @custom_includes)
 
           full = "#{base_dir}/#{rel}"
@@ -370,8 +381,9 @@ module Rubik
       # PERF: replacing "/" with NUL byte ("\x00") is equivalent to array component
       # comparison because NUL (0x00) is strictly less than any valid path byte,
       # avoiding intermediate Array allocations per path (~8.4x faster, ~62.5% fewer allocations).
+      # PERF: in-place sort_by! avoids array re-allocation
       def order_like_walker(paths)
-        paths.sort_by { |p| p.tr("/", "\x00") }
+        paths.sort_by! { |p| p.tr("/", "\x00") }
       end
 
       def parse_gitignore(dir = @root_dir)

data/lib/rubik/mcp/transport/stdio.rb

@@ -29,6 +29,7 @@ module Rubik
           @mutex = Mutex.new
           @cv = ConditionVariable.new
           @responses = {}
+          @closed = false
         end
 
         def open
@@ -78,6 +79,7 @@ module Rubik
           end
 
           @running = true
+          @closed = false
           @req_id = 0
           @responses.clear
 
@@ -118,8 +120,9 @@ module Rubik
         end
 
         def close
-          return unless @running || @wait_thr&.alive?
+          return if @closed
 
+          @closed = true
           @running = false
 
           begin
@@ -128,6 +131,16 @@ module Rubik
             nil
           end
 
+          if @wait_thr&.alive?
+            Rubik::Platform.kill_tree(@wait_thr.pid)
+            begin
+              @wait_thr.join(0.5)
+            rescue StandardError
+              nil
+            end
+          end
+          @wait_thr = nil
+
           [@stdin, @stdout, @stderr].each do |io|
             io&.close unless io&.closed?
           rescue StandardError
@@ -142,16 +155,6 @@ module Rubik
             @reader_thr = nil
           end
 
-          if @wait_thr&.alive?
-            Rubik::Platform.kill_tree(@wait_thr.pid)
-            begin
-              @wait_thr.join(0.5)
-            rescue StandardError
-              nil
-            end
-          end
-          @wait_thr = nil
-
           @mutex.synchronize do
             @responses.clear
             @cv.broadcast

data/lib/rubik/platform/process.rb

@@ -21,18 +21,90 @@ module Rubik
             nil
           end
         else
+          # On Unix/Linux, collect descendant PIDs so child processes are not
+          # orphaned when the parent process is killed.
+          descendants = descendant_pids(pid)
+          descendants.each do |cpid|
+            begin
+              ::Process.kill("TERM", cpid)
+            rescue StandardError
+              nil
+            end
+            begin
+              ::Process.kill("KILL", cpid)
+            rescue StandardError
+              nil
+            end
+          end
           begin
             ::Process.kill("TERM", pid)
-          rescue
+          rescue StandardError
             nil
           end
           begin
             ::Process.kill("KILL", pid)
-          rescue
+          rescue StandardError
             nil
           end
         end
       end
+
+      # Collect all descendant process IDs recursively (leaves first).
+      def descendant_pids(pid)
+        return [] unless pid&.positive?
+
+        collected = []
+        queue = [pid]
+        until queue.empty?
+          curr = queue.shift
+          children = direct_child_pids(curr)
+          children.each do |cpid|
+            next if collected.include?(cpid) || cpid == pid
+
+            collected << cpid
+            queue << cpid
+          end
+        end
+        collected.reverse
+      rescue StandardError
+        []
+      end
+
+      private
+
+      def direct_child_pids(pid)
+        task_dir = "/proc/#{pid}/task"
+        if File.directory?(task_dir)
+          pids = []
+          Dir.glob("#{task_dir}/*/children").each do |path|
+            content = begin
+              File.read(path)
+            rescue StandardError
+              nil
+            end
+            pids.concat(content.split.map(&:to_i)) if content
+          end
+          return pids.reject(&:zero?) unless pids.empty?
+        end
+
+        out = begin
+          `pgrep -P #{pid} 2>/dev/null`
+        rescue StandardError
+          nil
+        end
+        return out.lines.map(&:to_i).reject(&:zero?) if out && !out.empty?
+
+        out = begin
+          `ps --ppid #{pid} -o pid= 2>/dev/null`
+        rescue StandardError
+          nil
+        end
+        return out.lines.map(&:to_i).reject(&:zero?) if out && !out.empty?
+
+        []
+      rescue StandardError
+        []
+      end
     end
   end
 end