rubik 0.3.0 → 0.3.2

data/lib/rubik/tools/symbol_tool_support.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative "output"
+require_relative "diagnostic_reporter"
+require_relative "fuzzy_matcher"
+require_relative "truncator"
+
+module Rubik
+  module Tools
+    module SymbolToolSupport
+      def self.string_argument(args, primary, aliases: [], label: primary)
+        return [nil, ToolOutput.error("Tool arguments must be an object.")] unless args.is_a?(Hash)
+
+        values = [primary, *aliases].flat_map do |key|
+          [key.to_s, key.to_sym].uniq.filter_map { |actual| args[actual] if args.key?(actual) }
+        end
+        values.compact!
+        return [nil, nil] if values.empty?
+        return [nil, ToolOutput.error("#{label} must be a string.")] unless values.all?(String)
+
+        [values.first, nil]
+      end
+
+      def self.boolean_argument(args, key, label: key)
+        return [nil, ToolOutput.error("Tool arguments must be an object.")] unless args.is_a?(Hash)
+
+        values = [key.to_s, key.to_sym].uniq.filter_map { |actual| args[actual] if args.key?(actual) }
+        values.compact!
+        return [false, nil] if values.empty?
+        return [nil, ToolOutput.error("#{label} must be a boolean.")] unless values.all? { |value| [true, false].include?(value) }
+
+        [values.first, nil]
+      end
+
+      def self.warmup_output(graph)
+        return nil unless graph.respond_to?(:warmup_status)
+
+        status = graph.warmup_status
+        return nil unless status
+
+        state = status[:state] || status["state"]
+        if [:warming, "warming"].include?(state)
+          indexed = status[:indexed] || status["indexed"]
+          total = status[:total] || status["total"]
+          progress = if indexed.is_a?(Numeric) && total.is_a?(Numeric)
+                       " (#{indexed}/#{total} files indexed)"
+                     else
+                       ""
+                     end
+          ToolOutput.error("AST index warming; retry this request shortly#{progress}.")
+        elsif [:failed, "failed"].include?(state)
+          ToolOutput.error("AST index warmup failed; retry after running '!context scan'.")
+        end
+      end
+
+      def self.rank_matches(matches, query, graph)
+        symbol_map = graph.respond_to?(:symbols) ? graph.symbols : nil
+        qualified = symbol_map.respond_to?(:qualified_symbols) ? symbol_map.qualified_symbols : {}
+        keys_by_id = {}.compare_by_identity
+        qualified.sort_by { |key, _symbol| key }.each do |(key, symbol)|
+          keys_by_id[symbol] ||= key
+        end
+
+        matches.each_with_index.sort_by do |symbol, index|
+          name = symbol.name.to_s.downcase
+          lowered_query = query.downcase
+          rank = if name == lowered_query
+                   0
+                 elsif name.start_with?(lowered_query)
+                   1
+                 else
+                   2
+                 end
+          key = keys_by_id[symbol] || "#{symbol.file}##{symbol.name}"
+          [rank, key, index]
+        end.map(&:first)
+      end
+
+      def self.render_search(query, matches)
+        shown_count = [matches.length, 50].min
+        loop do
+          omitted = matches.length - shown_count
+          lines = ["Found #{matches.length} matching symbol(s) for '#{query}':"]
+          matches.first(shown_count).each do |sym|
+            lines << "• #{sym.kind.to_s.upcase} #{sym.name} (#{sym.file}:#{sym.line_start}-#{sym.line_end})"
+            lines << "  Signature: #{sym.signature}"
+            lines << "  Calls: #{sym.calls.join(', ')}"
+          end
+          lines << "... #{omitted} additional matches omitted." if omitted.positive?
+
+          truncated = Truncator.truncate(lines.join("\n"))
+          return truncated[:text] if !truncated[:truncated] || shown_count <= 1
+
+          shown_count -= 1
+        end
+      end
+
+      def self.fuzzy_candidate_names(graph)
+        symbols = graph.respond_to?(:symbols) ? graph.symbols : nil
+        return [] unless symbols
+
+        names = if symbols.respond_to?(:values)
+                  symbols.values.filter_map { |sym| sym.name if sym.respond_to?(:name) }.uniq
+                else
+                  []
+                end
+        return names unless names.empty?
+
+        symbols.respond_to?(:keys) ? symbols.keys : []
+      end
+    end
+  end
+end

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.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubik
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors:
 - Özgür Ulukır
@@ -249,6 +249,7 @@ files:
 - lib/rubik/ast/fallback_cleaner.rb
 - lib/rubik/ast/go_extractor.rb
 - lib/rubik/ast/graph.rb
+- lib/rubik/ast/graph_extensions.rb
 - lib/rubik/ast/python_extractor.rb
 - lib/rubik/ast/ruby_extractor.rb
 - lib/rubik/ast/rust_extractor.rb
@@ -757,6 +758,7 @@ files:
 - lib/rubik/tools/registry.rb
 - lib/rubik/tools/result.rb
 - lib/rubik/tools/services.rb
+- lib/rubik/tools/symbol_tool_support.rb
 - lib/rubik/tools/truncator.rb
 - lib/rubik/tools/uri_resolver.rb
 - lib/rubik/ui.rb