rubik 0.3.1 → 0.3.2

data/lib/rubik/lsp/manager.rb

@@ -42,6 +42,8 @@ module Rubik
         @context = context || runtime_manager&.context
         @clients = {}
         @crash_stats = {}
+        @recovery_errors = {}
+        @registered_disposable_langs = {}
         @monitor = Monitor.new
       end
 
@@ -93,82 +95,20 @@ module Rubik
       def ensure_healthy!(language_or_client)
         return nil unless enabled?
 
-        client = language_or_client.is_a?(Client) ? language_or_client : client_for(language_or_client)
-        return nil unless client
+        lang = language_for(language_or_client)
+        return nil unless lang
 
-        if client.running && client.respond_to?(:alive?) && !client.alive?
-          lang = client.language
-          record_crash(lang)
-          @monitor.synchronize do
-            begin
-              client.stop
-            rescue
-              nil
-            end
-            @clients.delete(lang)
-          end
-          start_client(lang) unless circuit_open?(lang)
-          client = @clients[lang]
-        elsif !client.running && @config.fetch("lsp.auto_start", true) && client.available? && !circuit_open?(client.language)
-          start_client(client.language)
-          client = @clients[client.language]
+        @monitor.synchronize do
+          preferred = language_or_client if language_or_client.is_a?(Client)
+          client_for_unlocked(lang, preferred)
         end
-
-        client
       end
 
       def client_for(language_or_file)
-        lang = if language_or_file.to_s.include?(".")
-                 detect_language(language_or_file)
-               else
-                 language_or_file.to_s.downcase
-               end
-
+        lang = language_for(language_or_file)
         return nil unless lang
 
-        @monitor.synchronize do
-          if @clients.key?(lang)
-            client = @clients[lang]
-            if client.running && client.respond_to?(:alive?) && !client.alive?
-              record_crash(lang)
-              begin
-                client.stop
-              rescue
-                nil
-              end
-              @clients.delete(lang)
-              nil # Will trigger recreate / start below
-            else
-              client
-            end
-          elsif enabled?
-            configured_cmd = @config.fetch("lsp.servers.#{lang}") || Client::SERVERS[lang]
-            client = Client.new(lang, root_dir: @root_dir, server_cmd: configured_cmd)
-            unless client.available?
-              probed_cmd = Runtime::Discovery.probe_lsp(lang, root_dir: @root_dir, custom_cmd: configured_cmd)
-              client = Client.new(lang, root_dir: @root_dir, server_cmd: probed_cmd) if probed_cmd
-            end
-
-            if client.available? && @config.fetch("lsp.auto_start", true) && !circuit_open?(lang)
-              if client.start
-                reset_circuit!(lang)
-                effective_ctx = @context || @runtime_manager&.context
-                if effective_ctx
-                  effective_ctx.provide("lsp:#{lang}", client)
-                  effective_ctx.register_disposable { client.stop if client.running }
-                end
-              else
-                record_crash(lang)
-                begin
-                  client.stop
-                rescue StandardError
-                  nil
-                end
-              end
-            end
-            @clients[lang] = client
-          end
-        end
+        @monitor.synchronize { client_for_unlocked(lang) }
       end
 
       def start_client(lang)
@@ -204,19 +144,12 @@ module Rubik
             @clients[lang_str] = client
             if res
               reset_circuit!(lang_str)
-              effective_ctx = @context || @runtime_manager&.context
-              if effective_ctx
-                effective_ctx.provide("lsp:#{lang_str}", client)
-                effective_ctx.register_disposable { client.stop if client.running }
-              end
+              @recovery_errors.delete(lang_str)
+              register_client_unlocked(lang_str, client)
               { ok: true, message: "Started LSP server for '#{lang_str}' (#{client.server_cmd})" }
             else
               record_crash(lang_str)
-              begin
-                client.stop
-              rescue StandardError
-                nil
-              end
+              stop_client_safely(client)
               failure = Runtime::DiagnosticEngine.diagnose(
                 cmd: client.server_cmd,
                 exit_code: 1,
@@ -241,13 +174,19 @@ module Rubik
 
           client.stop
           @clients.delete(lang_str)
+          effective_ctx = @context || @runtime_manager&.context
+          effective_ctx&.unprovide("lsp:#{lang_str}") if effective_ctx.respond_to?(:unprovide)
           { ok: true, message: "Stopped LSP server for '#{lang_str}'" }
         end
       end
 
       def stop_all
         @monitor.synchronize do
-          @clients.each_value(&:stop)
+          effective_ctx = @context || @runtime_manager&.context
+          @clients.each do |lang_str, client|
+            client.stop
+            effective_ctx&.unprovide("lsp:#{lang_str}") if effective_ctx.respond_to?(:unprovide)
+          end
           @clients.clear
         end
       end
@@ -317,21 +256,21 @@ module Rubik
 
       def hover(file_path, line, character)
         client = client_for(file_path)
-        return { ok: false, error: "LSP not active for '#{file_path}'" } unless client&.running
+        return { ok: false, error: inactive_client_error(file_path, client) } unless client&.running
 
         client.hover(file_path, line, character)
       end
 
       def definition(file_path, line, character)
         client = client_for(file_path)
-        return { ok: false, error: "LSP not active for '#{file_path}'" } unless client&.running
+        return { ok: false, error: inactive_client_error(file_path, client) } unless client&.running
 
         client.definition(file_path, line, character)
       end
 
       def references(file_path, line, character)
         client = client_for(file_path)
-        return { ok: false, error: "LSP not active for '#{file_path}'" } unless client&.running
+        return { ok: false, error: inactive_client_error(file_path, client) } unless client&.running
 
         client.references(file_path, line, character)
       end
@@ -361,6 +300,120 @@ module Rubik
           servers: client_statuses
         }
       end
+
+      private
+
+      def language_for(language_or_file)
+        if language_or_file.is_a?(Client)
+          language_or_file.language.to_s.downcase
+        elsif language_or_file.to_s.include?(".")
+          detect_language(language_or_file)
+        else
+          language_or_file.to_s.downcase
+        end
+      end
+
+      # Caller MUST hold @monitor. Dead-client removal and replacement startup
+      # happen in one critical section so concurrent requests share one client.
+      def client_for_unlocked(lang, preferred = nil)
+        stored = @clients[lang]
+        client = stored || preferred
+        recovering = false
+
+        if client && client_dead?(client)
+          recovering = true
+          record_crash(lang)
+          stop_client_safely(client)
+          @clients.delete(lang) if stored.equal?(client)
+          client = nil
+        end
+
+        if recovering && circuit_open?(lang)
+          @recovery_errors[lang] = "LSP server restart for '#{lang}' is blocked by the circuit breaker"
+          return nil
+        end
+        if recovering && !@config.fetch("lsp.auto_start", true)
+          @recovery_errors[lang] = "LSP server restart for '#{lang}' is disabled"
+          return nil
+        end
+
+        return nil unless client || enabled?
+
+        if client.nil?
+          configured_cmd = @config.fetch("lsp.servers.#{lang}") || Client::SERVERS[lang]
+          client = Client.new(lang, root_dir: @root_dir, server_cmd: configured_cmd)
+          unless client.available?
+            probed_cmd = Runtime::Discovery.probe_lsp(lang, root_dir: @root_dir, custom_cmd: configured_cmd)
+            client = Client.new(lang, root_dir: @root_dir, server_cmd: probed_cmd) if probed_cmd
+          end
+
+          if client.available? && @config.fetch("lsp.auto_start", true) && !circuit_open?(lang)
+            if client.start
+              reset_circuit!(lang)
+              @recovery_errors.delete(lang)
+              register_client_unlocked(lang, client)
+            else
+              record_crash(lang)
+              stop_client_safely(client)
+              @recovery_errors[lang] = "LSP server restart failed for '#{lang}'" if recovering
+            end
+          elsif recovering
+            @recovery_errors[lang] = if circuit_open?(lang)
+                                       "LSP server restart for '#{lang}' is blocked by the circuit breaker"
+                                     elsif !@config.fetch("lsp.auto_start", true)
+                                       "LSP server restart for '#{lang}' is disabled"
+                                     else
+                                       "LSP server restart failed for '#{lang}': server unavailable"
+                                     end
+          end
+          @clients[lang] = client
+        elsif !client.running && @config.fetch("lsp.auto_start", true) &&
+              client.available? && !circuit_open?(lang)
+          if client.start
+            reset_circuit!(lang)
+            @recovery_errors.delete(lang)
+            register_client_unlocked(lang, client)
+          else
+            record_crash(lang)
+            stop_client_safely(client)
+            @recovery_errors[lang] = "LSP server restart failed for '#{lang}'" if recovering
+          end
+        end
+
+        client
+      end
+
+      def client_dead?(client)
+        (client.running && client.respond_to?(:alive?) && !client.alive?) ||
+          (client.respond_to?(:crashed?) && client.crashed?)
+      end
+
+      def register_client_unlocked(lang, client)
+        effective_ctx = @context || @runtime_manager&.context
+        return unless effective_ctx
+
+        effective_ctx.provide("lsp:#{lang}", client)
+        return if @registered_disposable_langs[lang] == effective_ctx.object_id
+
+        @registered_disposable_langs[lang] = effective_ctx.object_id
+        effective_ctx.register_disposable do
+          current = @clients[lang]
+          current.stop if current&.running
+        end
+      end
+
+      def stop_client_safely(client)
+        client.stop
+      rescue StandardError
+        nil
+      end
+
+      def inactive_client_error(file_path, client)
+        lang = client&.language || detect_language(file_path)
+        @monitor.synchronize do
+          @recovery_errors[lang] || "LSP not active for '#{file_path}'"
+        end
+      end
     end
   end
 end

data/lib/rubik/orchestrator/tool_circuit_breaker.rb

@@ -35,15 +35,25 @@ module Rubik
           when :open
             return false unless cooldown_elapsed?(circuit)
 
-            # one probe through the half-open gate
+            # Cooldown elapsed: enter half-open state and grant single probe
             circuit[:state] = :half_open
             circuit[:probing] = true
+            circuit[:opened_at] = now
             true
           when :half_open
             if circuit[:probing]
-              true
+              # Probe is currently in flight. If probe wedged past cooldown,
+              # allow a new probe to prevent permanent deadlock.
+              if cooldown_elapsed?(circuit)
+                circuit[:opened_at] = now
+                true
+              else
+                false
+              end
             else
-              cooldown_elapsed?
+              circuit[:probing] = true
+              circuit[:opened_at] = now
+              true
             end
           else
             true
@@ -53,7 +63,7 @@ module Rubik
 
       def record_success(tool_name)
         @monitor.synchronize do
-          @tools.delete(tool_name)
+          @tools.delete(tool_name.to_s)
         end
       end
 
@@ -76,7 +86,7 @@ module Rubik
       private
 
       def circuit(tool_name)
-        @tools[tool_name] ||= { failures: 0, opened_at: nil, probing: false, state: :closed }
+        @tools[tool_name.to_s] ||= { failures: 0, opened_at: nil, probing: false, state: :closed }
       end
 
       def cooldown_elapsed?(circuit)

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/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/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