rubik 0.2.0 → 0.3.1

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.2.0"
+  VERSION = "0.3.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubik
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Özgür Ulukır
@@ -272,6 +272,7 @@ files:
 - lib/rubik/buffer/manager.rb
 - lib/rubik/buffer/path_validator.rb
 - lib/rubik/buffer/snapshot.rb
+- lib/rubik/cli/workspace_trust.rb
 - lib/rubik/coeffects.rb
 - lib/rubik/concurrency.rb
 - lib/rubik/concurrency/boundary.rb
@@ -357,12 +358,14 @@ files:
 - lib/rubik/orchestrator/stream_manager.rb
 - lib/rubik/orchestrator/subagent/activation.rb
 - lib/rubik/orchestrator/subagent/budget.rb
+- lib/rubik/orchestrator/subagent/builtin_types.rb
 - lib/rubik/orchestrator/subagent/completion.rb
 - lib/rubik/orchestrator/subagent/concurrency_gate.rb
 - lib/rubik/orchestrator/subagent/context_compaction.rb
 - lib/rubik/orchestrator/subagent/conversation_id.rb
 - lib/rubik/orchestrator/subagent/deferred_spec.rb
 - lib/rubik/orchestrator/subagent/dependency.rb
+- lib/rubik/orchestrator/subagent/dynamic_store.rb
 - lib/rubik/orchestrator/subagent/execution_reads.rb
 - lib/rubik/orchestrator/subagent/instance.rb
 - lib/rubik/orchestrator/subagent/journal.rb
@@ -371,6 +374,8 @@ files:
 - lib/rubik/orchestrator/subagent/narration.rb
 - lib/rubik/orchestrator/subagent/notices.rb
 - lib/rubik/orchestrator/subagent/operation_tracker.rb
+- lib/rubik/orchestrator/subagent/profile_contract.rb
+- lib/rubik/orchestrator/subagent/profile_snapshot.rb
 - lib/rubik/orchestrator/subagent/questioner.rb
 - lib/rubik/orchestrator/subagent/reaper.rb
 - lib/rubik/orchestrator/subagent/resilience.rb
@@ -378,6 +383,8 @@ files:
 - lib/rubik/orchestrator/subagent/reuse.rb
 - lib/rubik/orchestrator/subagent/run_cycle.rb
 - lib/rubik/orchestrator/subagent/scoped_registry.rb
+- lib/rubik/orchestrator/subagent/spawn_transaction.rb
+- lib/rubik/orchestrator/subagent/start_gate.rb
 - lib/rubik/orchestrator/subagent/step_runner.rb
 - lib/rubik/orchestrator/subagent/storage_id.rb
 - lib/rubik/orchestrator/subagent/supervisor.rb
@@ -386,6 +393,7 @@ files:
 - lib/rubik/orchestrator/subagent/tool_dispatch.rb
 - lib/rubik/orchestrator/subagent/transcript_formatter.rb
 - lib/rubik/orchestrator/subagent/transcript_reader.rb
+- lib/rubik/orchestrator/subagent/type_definition.rb
 - lib/rubik/orchestrator/subagent/type_registry.rb
 - lib/rubik/orchestrator/subagent/waiting.rb
 - lib/rubik/orchestrator/subagent_notice_inbox.rb
@@ -717,6 +725,7 @@ files:
 - lib/rubik/tools.rb
 - lib/rubik/tools/base.rb
 - lib/rubik/tools/builtins.rb
+- lib/rubik/tools/builtins/define_subagent.rb
 - lib/rubik/tools/builtins/dmesg.rb
 - lib/rubik/tools/builtins/exec.rb
 - lib/rubik/tools/builtins/files.rb