rubik 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14020218aa50674cdf508953465d4f31c285420979b8a9c518ef4d5e6f6ef300
-  data.tar.gz: caa28cd931b29aecf1de25e66d794a304f04ea0331e9b58f2b198c985488a8e2
+  metadata.gz: b71f1262ecc5dbd53e712da9df276b2fd744a1c797a05917ad4c103ead720b4c
+  data.tar.gz: 9c7d57397bfb5a8dfa4b34846bd51ec7ade3fcade0462cbf7f03d9d00ecb576c
 SHA512:
-  metadata.gz: 27fdbf68f5e00c88e87bdfe3ba33e837783b3b4a573ae3ccbd8db707fd7b320af8256c5a875811d33feaaf2118f18c701579266bdb2795d27815d0d0199d30b7
-  data.tar.gz: d050ff897cbe97a68399a31a28ca68e53f7edf7e894e097bbba338f722406975f397cd5fcd3fe21946c98d5c6a8a158f7193c04979d7878dcd985cdc524083b0
+  metadata.gz: 5994b70d91d9673cb1ea08f1eb39f9f04aa446ea9edcb61bc558d1b81f79825e205a12690dec3b652901d3176061b74012f48bd7a34d6f1b49c6d181219ada33
+  data.tar.gz: 79037bc56238a6eca4f6017e0d23c9b79af836fa5593281cb9005c31750a4f08513d0c78c8ca97c3f83b6cb41643757852a4021778b6c6e2da7a9187e9ea2120

data/CHANGELOG.md

@@ -10,6 +10,40 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 Nothing yet.
 
+## [0.3.1] - 2026-10-19
+
+A hygiene patch: the Truncator honors the budgets you give it across
+threads and separators, and the fuzzy matcher's Levenshtein fallback
+gets much cheaper and UTF-8 safe.
+
+### Fixed
+
+- **Truncator honors caller budgets (#189):** the `:head_tail`
+  strategy drops its hardcoded `clamp(1, 150)` / `clamp(1, 6000)`
+  caps — `max_lines` and `max_chars` are honored as given, small
+  budgets (`max_lines <= 1`) stay under their ceilings, and inputs
+  shorter than the budget no longer duplicate or overlap lines;
+  non-default separators no longer bypass the budget check (small
+  texts were wrongly reported `truncated: true`); omitted-line
+  accounting matches byte-budget slicing; and negative budgets clamp
+  to zero.
+- **Truncator line separation is thread-safe (#187):** `truncate`
+  takes an explicit `separator: "\n"` instead of reading the ambient
+  `$/` global, removing cross-thread separator races and the Ruby
+  3.4+ deprecation warnings.
+- **FuzzyMatcher survives invalid UTF-8 (#185):** the Levenshtein
+  fallback scrubs invalid byte sequences before codepoint iteration
+  instead of raising.
+
+### Changed
+
+- **Levenshtein fallback is ~31% faster with 96% fewer allocations
+  (#185):** codepoint iteration with a single mutation buffer
+  replaces per-character string and row-array churn.
+- **LSP reader-thread failures are structured (#184):** JSON parse
+  errors and reader exceptions log through `Rubik::Log.warn(:lsp, …)`
+  instead of bare `Kernel#warn`.
+
 ## [0.3.0] - 2026-10-18
 
 The subagent-governance minor: runtime-defined archetypes become

data/lib/rubik/lsp/client.rb

@@ -4,6 +4,7 @@ require "open3"
 require "json"
 require "uri"
 require_relative "../platform"
+require_relative "../log"
 
 module Rubik
   module LSP
@@ -347,12 +348,12 @@ module Rubik
                 parsed = JSON.parse(body)
                 handle_incoming_message(parsed)
               rescue StandardError => e
-                warn "[LSP::Client] Failed to handle message: #{e.class}: #{e.message}"
+                Rubik::Log.warn(:lsp, "Failed to handle message: #{e.class}: #{e.message}")
               end
             rescue IOError, Errno::EPIPE, Errno::ECONNRESET
               break
             rescue StandardError => e
-              warn "[LSP::Client] Reader loop error: #{e.class}: #{e.message}"
+              Rubik::Log.warn(:lsp, "Reader loop error: #{e.class}: #{e.message}")
               next
             end
           end

data/lib/rubik/tools/fuzzy_matcher.rb

@@ -81,29 +81,49 @@ module Rubik
 
       # Computes Levenshtein edit distance between two strings using standard dynamic programming.
       def self.levenshtein_distance(str1, str2)
-        return DidYouMean::Levenshtein.distance(str1.to_s, str2.to_s) if defined?(DidYouMean::Levenshtein) && DidYouMean::Levenshtein.respond_to?(:distance)
-
-        s1 = str1.to_s.chars
-        s2 = str2.to_s.chars
-        return s2.length if s1.empty?
-        return s1.length if s2.empty?
-
-        d = Array.new(s1.length + 1) { |i| i }
-
-        s2.each_with_index do |char2, j|
-          new_d = [j + 1]
-          s1.each_with_index do |char1, i|
+        return DidYouMean::Levenshtein.distance(str1.to_s.scrub, str2.to_s.scrub) if defined?(DidYouMean::Levenshtein) && DidYouMean::Levenshtein.respond_to?(:distance)
+
+        # PERF: Use codepoints instead of String#chars to avoid single-character String allocations,
+        # single-buffer array mutation instead of allocating row arrays (new_d), and fast while loops
+        # instead of each_with_index/Array#min blocks (~35% faster, zero inner loop allocations).
+        # scrub guarantees valid UTF-8 so codepoints never raises on
+        # malformed input (the previous .chars path tolerated bad bytes).
+        s1 = str1.to_s.scrub.codepoints
+        s2 = str2.to_s.scrub.codepoints
+        len1 = s1.length
+        len2 = s2.length
+        return len2 if len1.zero?
+        return len1 if len2.zero?
+
+        d = Array.new(len1 + 1) { |i| i }
+
+        j = 0
+        while j < len2
+          char2 = s2[j]
+          j += 1
+          new_d0 = j
+          prev = d[0]
+          i = 0
+          while i < len1
+            char1 = s1[i]
             cost = char1 == char2 ? 0 : 1
-            new_d << [
-              d[i + 1] + 1,       # deletion
-              new_d[i] + 1,       # insertion
-              d[i] + cost         # substitution
-            ].min
+            del = d[i + 1] + 1
+            ins = new_d0 + 1
+            sub = prev + cost
+
+            min_val = del
+            min_val = ins if ins < min_val
+            min_val = sub if sub < min_val
+            new_d0 = min_val
+
+            prev = d[i + 1]
+            d[i + 1] = new_d0
+            i += 1
           end
-          d = new_d
+          d[0] = j
         end
 
-        d.last
+        d[len1]
       end
 
       # Finds the closest matching line window in `file_content` for `target_content`

data/lib/rubik/tools/truncator.rb

@@ -1,14 +1,12 @@
 # frozen_string_literal: true
 
-require "English"
-
 module Rubik
   module Tools
     module Truncator
       DEFAULT_MAX_CHARS = 12_000
       DEFAULT_MAX_LINES = 300
 
-      def self.truncate(text, max_chars: DEFAULT_MAX_CHARS, max_lines: DEFAULT_MAX_LINES, strategy: :head_tail)
+      def self.truncate(text, max_chars: DEFAULT_MAX_CHARS, max_lines: DEFAULT_MAX_LINES, strategy: :head_tail, separator: "\n")
         str = text.to_s
         # byteslice truncation below cuts on byte boundaries and can split a
         # multibyte character, producing invalid UTF-8 that then poisons the
@@ -16,15 +14,14 @@ module Rubik
         # estimation). Scrub exactly once, after the last byteslice.
         str = str.scrub("") unless str.valid_encoding?
 
-        max_c = (max_chars || DEFAULT_MAX_CHARS).to_i
-        max_l = (max_lines || DEFAULT_MAX_LINES).to_i
+        max_c = [(max_chars || DEFAULT_MAX_CHARS).to_i, 0].max
+        max_l = [(max_lines || DEFAULT_MAX_LINES).to_i, 0].max
+        sep = separator || "\n"
 
-        # PERF: With the default input separator, calculate the line upper bound
+        # PERF: With the default newline separator, calculate the line upper bound
         # using zero-allocation C-level #count("\n") and short-circuit BEFORE
-        # calling #lines (which allocates an Array of line strings). Keep the
-        # original #lines behavior when callers customize Ruby's global record
-        # separator, since String#lines uses $/ when no separator is supplied.
-        if $INPUT_RECORD_SEPARATOR == "\n"
+        # calling #lines (which allocates an Array of line strings).
+        if sep == "\n"
           line_bound = if str.empty?
                          0
                        elsif str.end_with?("\n")
@@ -35,7 +32,8 @@ module Rubik
           return { text: str, truncated: false, omitted_lines: 0, omitted_chars: 0 } if str.bytesize <= max_c && line_bound <= max_l
         end
 
-        lines = str.lines
+        lines = str.lines(sep)
+        return { text: str, truncated: false, omitted_lines: 0, omitted_chars: 0 } if str.bytesize <= max_c && lines.size <= max_l
 
         strategy_sym = strategy.to_s.downcase.to_sym
 
@@ -44,7 +42,8 @@ module Rubik
           kept_lines = lines.first(max_l)
           kept_str = kept_lines.join
           kept_str = kept_str.byteslice(0, max_c) if kept_str.bytesize > max_c
-          omitted_lines = [lines.size - kept_lines.size, 0].max
+          kept_line_count = kept_str.empty? ? 0 : kept_str.lines(sep).size
+          omitted_lines = [lines.size - kept_line_count, 0].max
           omitted_chars = [str.bytesize - kept_str.bytesize, 0].max
           notice = "\n... [Truncated: omitted #{omitted_lines} lines / #{omitted_chars} chars] ...\n"
           { text: finalize(kept_str, notice, prefix: true), truncated: true,
@@ -53,29 +52,63 @@ module Rubik
           kept_lines = lines.last(max_l)
           kept_str = kept_lines.join
           kept_str = kept_str.byteslice(-max_c, max_c) if kept_str.bytesize > max_c
-          omitted_lines = [lines.size - kept_lines.size, 0].max
+          kept_line_count = kept_str.empty? ? 0 : kept_str.lines(sep).size
+          omitted_lines = [lines.size - kept_line_count, 0].max
           omitted_chars = [str.bytesize - kept_str.bytesize, 0].max
           notice = "\n... [Truncated: omitted #{omitted_lines} lines / #{omitted_chars} chars] ...\n"
           { text: finalize(kept_str, notice, prefix: false), truncated: true,
             omitted_lines: omitted_lines, omitted_chars: omitted_chars }
         else # :head_tail
-          half_lines = (max_l / 2).clamp(1, 150)
-          half_chars = (max_c / 2).clamp(1, 6000)
+          if max_l <= 1
+            kept_lines = lines.first(max_l)
+            kept_str = kept_lines.join
+            kept_str = kept_str.byteslice(0, max_c) if kept_str.bytesize > max_c
+            kept_line_count = kept_str.empty? ? 0 : kept_str.lines(sep).size
+            omitted_lines = [lines.size - kept_line_count, 0].max
+            omitted_chars = [str.bytesize - kept_str.bytesize, 0].max
+            notice = "\n\n... [Truncated: #{omitted_lines} lines / #{omitted_chars} chars omitted to preserve token budget] ...\n\n"
+            return { text: finalize(kept_str, notice, prefix: true), truncated: true,
+                     omitted_lines: omitted_lines, omitted_chars: omitted_chars }
+          end
+
+          head_lines_count = max_l / 2
+          tail_lines_count = max_l - head_lines_count
+
+          head_chars = max_c / 2
+          tail_chars = max_c - head_chars
 
-          head_lines = lines.first(half_lines)
-          tail_lines = lines.last(half_lines)
+          if lines.size == 1
+            head_lines = lines
+            tail_lines = lines
+          elsif head_lines_count + tail_lines_count >= lines.size
+            head_n = [head_lines_count, lines.size / 2].min
+            tail_n = [tail_lines_count, lines.size - head_n].min
+            head_lines = lines.first(head_n)
+            tail_lines = lines.last(tail_n)
+          else
+            head_lines = lines.first(head_lines_count)
+            tail_lines = lines.last(tail_lines_count)
+          end
 
           head_str = head_lines.join
           tail_str = tail_lines.join
 
-          head_str = head_str.byteslice(0, half_chars) if head_str.bytesize > half_chars
-          tail_str = tail_str.byteslice(-half_chars, half_chars) if tail_str.bytesize > half_chars
+          head_str = head_str.byteslice(0, head_chars) if head_str.bytesize > head_chars
+          tail_str = tail_str.byteslice(-tail_chars, tail_chars) if tail_str.bytesize > tail_chars
 
-          omitted_lines = [lines.size - (head_lines.size + tail_lines.size), 0].max
+          omitted_lines = if lines.size == 1
+                            0
+                          else
+                            head_k = head_str.empty? ? 0 : head_str.lines(sep).size
+                            tail_k = tail_str.empty? ? 0 : tail_str.lines(sep).size
+                            [lines.size - (head_k + tail_k), 0].max
+                          end
           omitted_chars = [str.bytesize - (head_str.bytesize + tail_str.bytesize), 0].max
           notice = "\n\n... [Truncated: #{omitted_lines} lines / #{omitted_chars} chars omitted to preserve token budget] ...\n\n"
 
-          { text: finalize(tail_str, finalize(head_str, notice, prefix: true), prefix: false), truncated: true,
+          head_final = head_str.valid_encoding? ? head_str : head_str.scrub("")
+          tail_final = tail_str.valid_encoding? ? tail_str : tail_str.scrub("")
+          { text: "#{head_final}#{notice}#{tail_final}", truncated: true,
             omitted_lines: omitted_lines, omitted_chars: omitted_chars }
         end
       end

data/lib/rubik/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rubik
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubik
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Özgür Ulukır