rubik 0.3.1 → 0.3.3

data/lib/rubik/platform.rb

@@ -87,7 +87,7 @@ module Rubik
 
       def home_dir
         Dir.home
-      rescue
+      rescue StandardError
         (ENV["USERPROFILE"] || (ENV.fetch("HOMEDRIVE",
                                           nil) && ENV.fetch("HOMEPATH",
                                                             nil) && "#{ENV.fetch('HOMEDRIVE',
@@ -96,7 +96,7 @@ module Rubik
 
       def tmp_dir
         Dir.tmpdir
-      rescue
+      rescue StandardError
         (ENV["TEMP"] || ENV["TMP"] || "/tmp")
       end
     end

data/lib/rubik/prompt/token_estimator.rb

@@ -34,7 +34,7 @@ module Rubik
 
         tool_calls = msg[:tool_calls] || msg["tool_calls"]
         if tool_calls && !tool_calls.empty?
-          tool_calls_str = tool_calls.is_a?(String) ? Rubik::Platform.clean_utf8(tool_calls) : Rubik::Platform.safe_json_generate(tool_calls)
+          tool_calls_str = serialize_for_estimation(tool_calls)
           tokens += estimate_text(tool_calls_str)
         end
 
@@ -57,8 +57,20 @@ module Rubik
         return 0 if schemas.nil?
         return 0 if schemas.respond_to?(:empty?) && schemas.empty?
 
-        json_str = schemas.is_a?(String) ? Rubik::Platform.clean_utf8(schemas) : Rubik::Platform.safe_json_generate(schemas)
-        estimate_text(json_str)
+        estimate_text(serialize_for_estimation(schemas))
+      end
+
+      # PERF: Fast-path JSON generation for tool_calls and tool_schemas estimation.
+      # Uses direct JSON.generate to avoid deep clean_utf8 traversal, falling back
+      # to Rubik::Platform.safe_json_generate only when malformed UTF-8 raises.
+      def serialize_for_estimation(obj)
+        return Rubik::Platform.clean_utf8(obj) if obj.is_a?(String)
+
+        begin
+          JSON.generate(obj)
+        rescue StandardError
+          Rubik::Platform.safe_json_generate(obj)
+        end
       end
     end
   end

data/lib/rubik/repl/ast_warmup.rb

@@ -22,10 +22,15 @@ module Rubik
           # Reset the cooperative-stop flag so repeated warm cycles behave the
           # same as the first (per-turn scopes, MCP reconnects, tool epochs).
           @indexer_stop_requested = false
+          warmup_token = @ast_graph.begin_warmup if @ast_graph.respond_to?(:begin_warmup)
           @indexer_thread = Thread.new do
+            Thread.current[:rubik_ast_warmup_token] = warmup_token
             perform_warm_ast_graph
           rescue StandardError => e
+            @ast_graph.finish_warmup(warmup_token, state: :failed) if warmup_token
             @logger&.warn("AST graph background indexer thread error: #{e.class}: #{e.message}")
+          ensure
+            Thread.current[:rubik_ast_warmup_token] = nil
           end
           ctx = @runtime_manager&.context || (respond_to?(:context) ? context : nil)
           if ctx.respond_to?(:register_disposable) && ctx != @indexer_disposable_ctx
@@ -33,7 +38,16 @@ module Rubik
             ctx.register_disposable { stop_background_indexer }
           end
         else
-          perform_warm_ast_graph
+          @indexer_stop_requested = false
+          warmup_token = @ast_graph.begin_warmup if @ast_graph.respond_to?(:begin_warmup)
+          previous_token = Thread.current[:rubik_ast_warmup_token]
+          Thread.current[:rubik_ast_warmup_token] = warmup_token
+          begin
+            perform_warm_ast_graph
+          ensure
+            Thread.current[:rubik_ast_warmup_token] = previous_token
+            @ast_graph.finish_warmup(warmup_token) if warmup_token
+          end
         end
       end
 
@@ -82,6 +96,9 @@ module Rubik
       end
 
       def perform_warm_ast_graph
+        warmup_token = Thread.current[:rubik_ast_warmup_token]
+        warmup_token ||= @ast_graph.begin_warmup if @ast_graph.respond_to?(:begin_warmup)
+        warmup_state = :ready
         root_d = @buffer_manager&.root_dir || Dir.pwd
         delta = @context_index.incremental_scan
         indexed_files = @ast_graph.file_symbols.keys
@@ -96,12 +113,21 @@ module Rubik
           files_to_index << rel_file if Rubik::AST::Extractor.supported_extensions.include?(ext) && !(indexed_files.include?(full_path) || indexed_files.include?(rel_file))
         end
 
-        files_to_index.uniq.each do |rel_file|
+        files_to_process = files_to_index.uniq.select do |rel_file|
+          ext = File.extname(rel_file).downcase
+          Rubik::AST::Extractor.supported_extensions.include?(ext) && File.exist?(File.join(root_d, rel_file))
+        end
+        total_operations = files_to_process.length + delta[:deleted].length
+        @ast_graph.update_warmup(warmup_token, indexed: 0, total: total_operations) if warmup_token
+        completed_operations = 0
+
+        files_to_process.each do |rel_file|
           break if @indexer_stop_requested
 
           full_path = File.join(root_d, rel_file)
-          ext = File.extname(rel_file).downcase
-          @ast_graph.index_file(full_path) if Rubik::AST::Extractor.supported_extensions.include?(ext) && File.exist?(full_path)
+          @ast_graph.index_file(full_path)
+          completed_operations += 1
+          @ast_graph.update_warmup(warmup_token, indexed: completed_operations, total: total_operations) if warmup_token
         end
 
         delta[:deleted].each do |rel_file|
@@ -109,6 +135,8 @@ module Rubik
 
           full_path = File.join(root_d, rel_file)
           @ast_graph.remove_file(full_path)
+          completed_operations += 1
+          @ast_graph.update_warmup(warmup_token, indexed: completed_operations, total: total_operations) if warmup_token
         end
 
         return if @indexer_stop_requested
@@ -120,9 +148,12 @@ module Rubik
           @ast_graph.save_to_cache(@cache_store)
         end
       rescue StandardError => e
+        warmup_state = :failed
         @logger&.warn("AST graph warm failed: #{e.message}")
         @event_bus&.emit(:ast_warm_failed, error: e.message)
         nil
+      ensure
+        @ast_graph.finish_warmup(warmup_token, state: warmup_state) if warmup_token
       end
     end
   end

data/lib/rubik/repl/commands/subagents.rb

@@ -113,10 +113,7 @@ module Rubik
         end
 
         def self.handle_kill(ctx, sup, id)
-          if id.to_s.strip.empty?
-            ctx.out.puts "Usage: !subagents kill <subagent_id>"
-            return
-          end
+          return ctx.out.puts "Usage: !subagents kill <subagent_id>" if id.to_s.strip.empty?
 
           if sup.kill(id)
             ctx.out.puts "Subagent '#{id}' and child tree killed."
@@ -126,17 +123,21 @@ module Rubik
         end
 
         def self.handle_extend(ctx, sup, id, steps_arg)
-          if id.to_s.strip.empty?
-            ctx.out.puts "Usage: !subagents extend <subagent_id> [additional_steps]"
-            return
-          end
+          return ctx.out.puts "Usage: !subagents extend <subagent_id> [additional_steps]" if id.to_s.strip.empty?
 
           steps = Rubik::Orchestrator::Subagent::Budget.normalize_grant(steps_arg)
+          inst = sup.get(id)
           if sup.extend_budget(id, steps)
-            inst = sup.get(id)
-            ctx.out.puts "Extended budget for #{id} by #{steps} steps (total: #{inst.max_steps}, state: #{inst.state.to_s.upcase})."
+            ceiling = inst.respond_to?(:max_total_steps) ? "/#{inst.max_total_steps}" : ""
+            ctx.out.puts "Extended budget for #{id} by #{steps} steps (total: #{inst.max_steps}#{ceiling}, " \
+                         "state: #{inst.state.to_s.upcase})."
           else
-            ctx.out.puts "Could not extend budget for #{id} (not found or inactive)."
+            msg = if inst.respond_to?(:max_total_steps) && inst.max_steps >= inst.max_total_steps
+                    "Could not extend budget for #{id}: lifetime step limit of #{inst.max_total_steps} reached."
+                  else
+                    "Could not extend budget for #{id} (not found or inactive)."
+                  end
+            ctx.out.puts msg
           end
         end
 

data/lib/rubik/repl/interrupt_handler.rb

@@ -89,14 +89,14 @@ module Rubik
               if get_std_handle
                 new_in = begin
                   get_std_handle.call(Reline::Windows::STD_INPUT_HANDLE)
-                rescue
+                rescue StandardError
                   nil
                 end
                 io.instance_variable_set(:@hConsoleInputHandle, new_in) if new_in && new_in != 0
 
                 new_out = begin
                   get_std_handle.call(Reline::Windows::STD_OUTPUT_HANDLE)
-                rescue
+                rescue StandardError
                   nil
                 end
                 io.instance_variable_set(:@hConsoleHandle, new_out) if new_out && new_out != 0
@@ -105,14 +105,14 @@ module Rubik
                   flush_func = io.instance_variable_get(:@FlushConsoleInputBuffer) ||
                                begin
                                  Reline::Windows::Win32API.new("kernel32", "FlushConsoleInputBuffer", ["L"], "I")
-                               rescue
+                               rescue StandardError
                                  nil
                                end
                   if flush_func
                     io.instance_variable_set(:@FlushConsoleInputBuffer, flush_func)
                     begin
                       flush_func.call(new_in)
-                    rescue
+                    rescue StandardError
                       nil
                     end
                   end
@@ -143,7 +143,7 @@ if defined?(Reline::Windows)
         if @hConsoleInputHandle.nil? || @hConsoleInputHandle.zero? || @hConsoleInputHandle == -1
           @hConsoleInputHandle = begin # rubocop:disable Naming/VariableName -- Win32 FFI SDK adlandırması; yalnızca Windows konsol yolu
             @GetStdHandle.call(STD_INPUT_HANDLE)
-          rescue
+          rescue StandardError
             nil
           end
         end
@@ -156,18 +156,18 @@ if defined?(Reline::Windows)
             if [0xFFFFFFFF, 4_294_967_295, -1].include?(wait_res)
               @hConsoleInputHandle = begin # rubocop:disable Naming/VariableName -- Win32 FFI SDK adlandırması; yalnızca Windows konsol yolu
                 @GetStdHandle.call(STD_INPUT_HANDLE)
-              rescue
+              rescue StandardError
                 nil
               end
               @hConsoleHandle = begin # rubocop:disable Naming/VariableName -- Win32 FFI SDK adlandırması; yalnızca Windows konsol yolu
                 @GetStdHandle.call(STD_OUTPUT_HANDLE)
-              rescue
+              rescue StandardError
                 nil
               end
             end
             @legacy_console = begin
               getconsolemode.nobits?(ENABLE_VIRTUAL_TERMINAL_PROCESSING)
-            rescue
+            rescue StandardError
               false
             end
             next
@@ -175,7 +175,7 @@ if defined?(Reline::Windows)
           if @GetNumberOfConsoleInputEvents.call(@hConsoleInputHandle, num_of_events).zero? || num_of_events.unpack1("L").zero?
             @hConsoleInputHandle = begin # rubocop:disable Naming/VariableName -- Win32 FFI SDK adlandırması; yalnızca Windows konsol yolu
               @GetStdHandle.call(STD_INPUT_HANDLE)
-            rescue
+            rescue StandardError
               nil
             end
             next
@@ -185,7 +185,7 @@ if defined?(Reline::Windows)
           if @ReadConsoleInputW.call(@hConsoleInputHandle, input_records, 80, read_event).zero?
             @hConsoleInputHandle = begin # rubocop:disable Naming/VariableName -- Win32 FFI SDK adlandırması; yalnızca Windows konsol yolu
               @GetStdHandle.call(STD_INPUT_HANDLE)
-            rescue
+            rescue StandardError
               nil
             end
           else

data/lib/rubik/repl/shell.rb

@@ -119,7 +119,7 @@ module Rubik
 
       def search_symbols(query)
         join_indexer_safely(0.2) if @ast_graph.symbols.empty? && @indexer_thread&.alive?
-        @ast_graph.symbols.values.select { |sym| sym.name.downcase.include?(query.downcase) }
+        @ast_graph.search_symbols(query)
       end
 
       def register_command(name, description:, usage: nil, custom: false, audience: nil, &handler)

data/lib/rubik/tools/builtins/subagent.rb

@@ -251,10 +251,15 @@ module Rubik
           return ToolOutput.error("Missing required parameter 'conversation_id' for action 'extend_budget'.") if id.empty?
 
           steps = Rubik::Orchestrator::Subagent::Budget.normalize_grant(args["steps"] || args[:steps])
+          inst = sup.get(id)
           if sup.extend_budget(id, steps)
-            "Step budget for subagent '#{id}' successfully extended by #{steps} steps (total budget: #{sup.get(id).max_steps}, state: #{sup.get(id).state.to_s.upcase})."
+            ceiling = inst.respond_to?(:max_total_steps) ? "/#{inst.max_total_steps}" : ""
+            "Step budget for subagent '#{id}' successfully extended by #{steps} steps (total budget: #{inst.max_steps}#{ceiling}, " \
+              "state: #{inst.state.to_s.upcase})."
+          elsif inst.respond_to?(:max_total_steps) && inst.max_steps >= inst.max_total_steps
+            ToolOutput.error("Subagent '#{id}' reached its lifetime step limit (#{inst.max_total_steps}); no more steps can be granted.")
           else
-            ToolOutput.error("Subagent '#{id}' not found or cannot extend budget (current state: #{sup.get(id)&.state || 'not found'}).")
+            ToolOutput.error("Subagent '#{id}' not found or cannot extend budget (current state: #{inst&.state || 'not found'}).")
           end
         when "resume"
           id = resolve_id(args)

data/lib/rubik/tools/builtins/symbols.rb

@@ -2,9 +2,7 @@
 
 require_relative "../base"
 require_relative "../../coeffects"
-require_relative "../output"
-require_relative "../diagnostic_reporter"
-require_relative "../fuzzy_matcher"
+require_relative "../symbol_tool_support"
 
 module Rubik
   module Tools
@@ -36,13 +34,22 @@ module Rubik
       end
 
       def execute(args = {})
-        query = (args["query"] || args[:query]).to_s.strip
-        return ToolOutput.error("Query parameter is required.") if query.empty?
+        query, error = SymbolToolSupport.string_argument(args, "query", label: "query")
+        return error if error
+        return ToolOutput.error("Query parameter is required.") if query.nil? || query.strip.empty?
+
+        query = query.strip
+
+        smart_context, error = SymbolToolSupport.boolean_argument(args, "smart_context", label: "smart_context")
+        return error if error
 
         graph = ast_graph
         return ToolOutput.error("AST graph is not available. Run '!context scan' to build the symbol index.") unless graph
 
-        if args["smart_context"] || args[:smart_context]
+        warming = SymbolToolSupport.warmup_output(graph)
+        return warming if warming
+
+        if smart_context
           ctx = graph.smart_context_for(query)
           return ctx.empty? ? "No smart context found for '#{query}'." : ctx
         end
@@ -54,14 +61,12 @@ module Rubik
                   end
 
         if matches.empty?
-          all_sym_names = graph.respond_to?(:symbols) ? graph.symbols.keys : []
+          all_sym_names = SymbolToolSupport.fuzzy_candidate_names(graph)
           candidates = FuzzyMatcher.best_matches(query, all_sym_names)
-          DiagnosticReporter.render_symbol_not_found(query, candidate_symbols: candidates)
+          ToolOutput.error(DiagnosticReporter.render_symbol_not_found(query, candidate_symbols: candidates))
         else
-          matches.map do |sym|
-            "• #{sym.kind.to_s.upcase} #{sym.name} (#{sym.file}:#{sym.line_start}-#{sym.line_end})\n  " \
-              "Signature: #{sym.signature}\n  Calls: #{sym.calls.join(', ')}"
-          end.join("\n\n")
+          ranked = SymbolToolSupport.rank_matches(matches, query, graph)
+          SymbolToolSupport.render_search(query, ranked)
         end
       end
     end
@@ -95,13 +100,24 @@ module Rubik
       end
 
       def execute(args = {})
-        path = (args["file_path"] || args[:file_path] || args["path"] || args[:path]).to_s.strip
-        return ToolOutput.error("File path is required.") if path.empty?
+        path, error = SymbolToolSupport.string_argument(args, "file_path", aliases: ["path"], label: "file_path")
+        return error if error
+        return ToolOutput.error("File path is required.") if path.nil? || path.strip.empty?
+
+        path = path.strip
 
         graph = ast_graph
         return ToolOutput.error("AST graph is not available. Run '!context scan' to build the symbol index.") unless graph
 
-        graph.outline_for(path)
+        warming = SymbolToolSupport.warmup_output(graph)
+        return warming if warming
+
+        outline = graph.outline_for(path)
+        status = graph.extraction_status(path) if graph.respond_to?(:extraction_status)
+        return ToolOutput.error("Outline extraction failed for '#{path}'.") if status == :failed
+        return "#{outline}\n[Partial extraction: some symbols may be missing.]" if status == :partial
+
+        outline
       end
     end
 
@@ -134,12 +150,18 @@ module Rubik
       end
 
       def execute(args = {})
-        sym_name = (args["symbol_name"] || args[:symbol_name] || args["symbol"] || args[:symbol]).to_s.strip
-        return ToolOutput.error("Symbol name is required.") if sym_name.empty?
+        sym_name, error = SymbolToolSupport.string_argument(args, "symbol_name", aliases: ["symbol"], label: "symbol_name")
+        return error if error
+        return ToolOutput.error("Symbol name is required.") if sym_name.nil? || sym_name.strip.empty?
+
+        sym_name = sym_name.strip
 
         graph = ast_graph
         return ToolOutput.error("AST graph is not available. Run '!context scan' to build the symbol index.") unless graph
 
+        warming = SymbolToolSupport.warmup_output(graph)
+        return warming if warming
+
         callers = graph.callers_of(sym_name)
         if callers.empty?
           "No references or callers found for '#{sym_name}' in AST graph."
@@ -150,6 +172,8 @@ module Rubik
           end
           lines.join("\n")
         end
+      rescue Rubik::AST::Graph::AmbiguousSymbolError => e
+        ToolOutput.error(e.message)
       end
     end
 
@@ -181,15 +205,27 @@ module Rubik
       end
 
       def execute(args = {})
-        sym_name = (args["symbol_name"] || args[:symbol_name] || args["symbol"] || args[:symbol]).to_s.strip
-        return ToolOutput.error("Symbol name is required.") if sym_name.empty?
+        sym_name, error = SymbolToolSupport.string_argument(args, "symbol_name", aliases: ["symbol"], label: "symbol_name")
+        return error if error
+        return ToolOutput.error("Symbol name is required.") if sym_name.nil? || sym_name.strip.empty?
+
+        sym_name = sym_name.strip
 
         graph = ast_graph
         return ToolOutput.error("AST graph is not available. Run '!context scan' to build the symbol index.") unless graph
 
+        warming = SymbolToolSupport.warmup_output(graph)
+        return warming if warming
+
+        candidates = graph.symbol_candidates(sym_name) if graph.respond_to?(:symbol_candidates)
+        if candidates && candidates.length > 1
+          message = "Ambiguous symbol '#{sym_name}'. Use a qualified key. Candidates:\n- #{candidates.join("\n- ")}"
+          return ToolOutput.error(message)
+        end
+
         info = graph.symbol_definition(sym_name)
         unless info
-          all_sym_names = graph.respond_to?(:symbols) ? graph.symbols.keys : []
+          all_sym_names = SymbolToolSupport.fuzzy_candidate_names(graph)
           candidates = FuzzyMatcher.best_matches(sym_name, all_sym_names)
           return ToolOutput.error(DiagnosticReporter.render_symbol_not_found(sym_name, candidate_symbols: candidates))
         end

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/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubik
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.3
 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