rubik 0.4.1 → 0.4.2

data/lib/rubik/mcp/proxy_tool.rb

@@ -91,6 +91,23 @@ module Rubik
             output: output_text
           )
         end
+      rescue ConnectionError, TimeoutError => e
+        tail = if @client.respond_to?(:stderr_tail)
+                 @client.stderr_tail
+               elsif @client.respond_to?(:transport) && @client.transport.respond_to?(:stderr_tail)
+                 @client.transport.stderr_tail
+               else
+                 []
+               end
+        tail_lines = Array(tail).last(3)
+        stderr_detail = tail_lines.empty? ? "" : "; server stderr: #{tail_lines.join(' | ')}"
+        err_msg = "MCP server '#{@server_name}' is unreachable (#{e.class}: #{e.message}); its proxy tools are unavailable until reconnect or `!mcp` re-add#{stderr_detail}"
+        Rubik::Tools::Result.new(
+          tool_name: @name,
+          status: :error,
+          output: err_msg,
+          error: err_msg
+        )
       rescue StandardError => e
         Rubik::Tools::Result.new(
           tool_name: @name,

data/lib/rubik/mcp/transport/stdio.rb

@@ -11,6 +11,11 @@ module Rubik
   module MCP
     module Transport
       class Stdio
+        # The child's stderr pipe is drained continuously (see
+        # #start_stderr_thread); this many recent lines stay queryable via
+        # #stderr_tail for diagnostics.
+        STDERR_TAIL_LINES = 20
+
         attr_reader :command, :args, :env, :root_dir, :running, :wait_thr
 
         def initialize(command, args: [], env: {}, root_dir: Dir.pwd, guard: nil)
@@ -26,14 +31,25 @@ module Rubik
           @stderr = nil
           @wait_thr = nil
           @reader_thr = nil
+          @stderr_thr = nil
+          @stderr_mutex = Mutex.new
+          @stderr_tail = []
           @mutex = Mutex.new
           @cv = ConditionVariable.new
           @responses = {}
           @closed = false
+          @generation = 0
+          @pending_requests = Set.new
         end
 
         def open
-          return if @running
+          return if running?
+
+          # A previous incarnation whose child died on its own (the reader's
+          # ensure cleared @running) still holds pipe FDs and an unreaped
+          # wait thread; re-spawning over them leaks both. close is
+          # idempotent and a no-op when nothing lingers.
+          close if @wait_thr || @reader_thr || @stderr_thr
 
           cmd_parts = if @args.empty? && @command.is_a?(String)
                         begin
@@ -78,21 +94,29 @@ module Rubik
             raise ConnectionError, "Failed to spawn MCP process '#{bin}': #{e.message}"
           end
 
-          @running = true
-          @closed = false
-          @req_id = 0
-          @responses.clear
+          @mutex.synchronize do
+            @running = true
+            @closed = false
+            @generation += 1
+            @req_id = 0
+            @responses.clear
+            @pending_requests.clear
+          end
+          @stderr_mutex.synchronize { @stderr_tail.clear }
 
+          start_stderr_thread
           start_reader_thread
           self
         end
         alias start open
 
         def send_request(method, params = {}, timeout: 10)
-          raise ConnectionError, "MCP transport is not running" unless @running && @stdin
+          raise ConnectionError, "MCP transport is not running" unless running? && @stdin
 
           req_id = @mutex.synchronize do
             @req_id += 1
+            @pending_requests.add(@req_id)
+            @pending_requests.add(@req_id.to_s)
             @req_id
           end
 
@@ -103,8 +127,17 @@ module Rubik
             "params" => params || {}
           }
 
-          write_message(msg)
-          wait_for_response(req_id, timeout: timeout)
+          begin
+            write_message(msg)
+            wait_for_response(req_id, timeout: timeout)
+          ensure
+            @mutex.synchronize do
+              @pending_requests.delete(req_id)
+              @pending_requests.delete(req_id.to_s)
+              @responses.delete(req_id)
+              @responses.delete(req_id.to_s)
+            end
+          end
         end
 
         def send_notification(method, params = {})
@@ -120,10 +153,14 @@ module Rubik
         end
 
         def close
-          return if @closed
+          child_died = false
+          @mutex.synchronize do
+            return if @closed
 
-          @closed = true
-          @running = false
+            child_died = !@running
+            @closed = true
+            @running = false
+          end
 
           begin
             @reader_thr&.kill
@@ -131,13 +168,32 @@ module Rubik
             nil
           end
 
+          begin
+            @stderr_thr&.kill
+          rescue StandardError
+            nil
+          end
+
           if @wait_thr&.alive?
-            Rubik::Platform.kill_tree(@wait_thr.pid)
+            pid_to_kill = @wait_thr.pid
+            Rubik::Platform.kill_tree(pid_to_kill)
             begin
               @wait_thr.join(0.5)
             rescue StandardError
               nil
             end
+
+            if @wait_thr.alive?
+              abandoned_waiter = @wait_thr
+              Thread.new do
+                begin
+                  abandoned_waiter.join(2.5)
+                rescue StandardError
+                  nil
+                end
+                Rubik::Log.warn(:mcp, "abandoned child process pid #{pid_to_kill} did not exit within reaper window") if abandoned_waiter.alive?
+              end
+            end
           end
           @wait_thr = nil
 
@@ -155,8 +211,22 @@ module Rubik
             @reader_thr = nil
           end
 
+          begin
+            @stderr_thr&.join(0.5)
+          rescue StandardError
+            nil
+          ensure
+            @stderr_thr = nil
+          end
+
+          if child_died
+            hint = stderr_tail.last(5).join(" | ")[0, 512]
+            Rubik::Log.warn(:mcp, "MCP child process (pid #{pid}) had already exited; recent stderr: #{hint}") unless hint.empty?
+          end
+
           @mutex.synchronize do
             @responses.clear
+            @pending_requests.clear
             @cv.broadcast
           end
         end
@@ -164,7 +234,17 @@ module Rubik
         alias dispose close
 
         def running?
-          @running && (@wait_thr.nil? || @wait_thr.alive?)
+          @mutex.synchronize do
+            @running && (@wait_thr.nil? || @wait_thr.alive?)
+          end
+        end
+
+        # Recent stderr output from the child (last STDERR_TAIL_LINES lines).
+        # The drain keeps the OS pipe buffer empty so a chatty server can
+        # never block on stderr write; the tail is what makes that output
+        # diagnosable instead of silently discarded.
+        def stderr_tail
+          @stderr_mutex.synchronize { @stderr_tail.dup }
         end
 
         def pid
@@ -198,7 +278,12 @@ module Rubik
               remaining = timeout - elapsed
               if remaining <= 0
                 @responses.delete(req_id)
-                raise TimeoutError, "Timed out waiting for MCP response to request #{req_id} after #{timeout}s"
+                # The stderr tail is the one place a wedged server explains
+                # itself (crash traces, logging storms); attach it so the
+                # timeout is diagnosable instead of opaque.
+                hint = stderr_tail.last(3).join(" | ")[0, 512]
+                suffix = hint.empty? ? "" : "; server stderr: #{hint}"
+                raise TimeoutError, "Timed out waiting for MCP response to request #{req_id} after #{timeout}s#{suffix}"
               end
 
               @cv.wait(@mutex, remaining)
@@ -217,8 +302,9 @@ module Rubik
         end
 
         def start_reader_thread
+          gen = @mutex.synchronize { @generation }
           @reader_thr = Thread.new do
-            while @running && @stdout && !@stdout.closed?
+            while @mutex.synchronize { @running } && @stdout && !@stdout.closed?
               line = begin
                 @stdout.gets
               rescue IOError, Errno::EBADF
@@ -238,9 +324,46 @@ module Rubik
             end
           ensure
             @mutex.synchronize do
-              @running = false
-              @cv.broadcast
+              if @generation == gen
+                @running = false
+                @cv.broadcast
+              end
+            end
+          end
+        end
+
+        # Drain the child's stderr on its own thread. Without a reader, a
+        # server that logs more than the OS pipe buffer holds (~64KB on
+        # Linux, far less on Windows) blocks inside its write() and stops
+        # answering requests — every call then times out with no hint that
+        # the child is wedged on its own logging. EOF on stderr must NOT
+        # stop the transport: a child may close stderr and keep serving.
+        def start_stderr_thread
+          @stderr_thr = Thread.new do
+            while @running && @stderr && !@stderr.closed?
+              line = begin
+                @stderr.gets
+              rescue IOError, Errno::EBADF
+                nil
+              end
+              break unless line
+
+              line = line.chomp
+              # Cap retained size per line: a newline-less flood must not
+              # turn the diagnostic tail into a memory hog.
+              line = line[0, 4096] if line.length > 4096
+
+              @stderr_mutex.synchronize do
+                @stderr_tail << line
+                @stderr_tail.shift while @stderr_tail.length > STDERR_TAIL_LINES
+              end
             end
+          rescue IOError, Errno::EBADF
+            nil
+          rescue StandardError => e
+            # A silently dead drainer would recreate the exact wedge this
+            # thread exists to prevent — make its death greppable.
+            Rubik::Log.warn(:mcp, "stderr drain thread exited unexpectedly (#{e.class}: #{e.message}); the MCP child may block on a full stderr pipe")
           end
         end
 
@@ -248,6 +371,8 @@ module Rubik
           return unless msg.is_a?(Hash) && msg.key?("id")
 
           @mutex.synchronize do
+            return unless @pending_requests.include?(msg["id"])
+
             @responses[msg["id"]] = msg
             @cv.broadcast
           end

data/lib/rubik/plugin/manager.rb

@@ -100,30 +100,44 @@ module Rubik
       def load_dropin_plugins(runtime_manager:, storage:)
         plugins = storage.discover_plugins
         plugins.each do |plugin_meta|
-          integrity = storage.verify_integrity(plugin_meta[:path], scope: plugin_meta[:scope])
+          content = File.exist?(plugin_meta[:path]) ? File.binread(plugin_meta[:path]) : nil
+          integrity = storage.verify_integrity(plugin_meta[:path], scope: plugin_meta[:scope], content: content)
           if integrity == :rejected
             @logger.warn("Skipping drop-in plugin '#{plugin_meta[:name]}' due to integrity check failure.")
             next
           end
 
-          load_plugin_file(plugin_meta, runtime_manager: runtime_manager)
+          load_plugin_file(plugin_meta, runtime_manager: runtime_manager, content: content)
         end
       end
 
-      def load_plugin_file(plugin_meta, runtime_manager:)
+      def load_plugin_file(plugin_meta, runtime_manager:, content: nil)
         name = plugin_meta[:name]
         component_name = "plugin_#{name}"
 
-        unload_plugin(name, runtime_manager: runtime_manager) if runtime_manager.fibers.key?(component_name)
+        # If plugin is already running, prepare the replacement first (issue #309).
+        # Unloading before prepare would destroy the live plugin if the replacement has a syntax/prepare error.
+        already_running = runtime_manager.fibers.key?(component_name)
+        previous_def = Rubik::Plugin::Registry.get(name) if already_running
+        previous_fiber = runtime_manager.fibers[component_name] if already_running
+        was_active = previous_fiber&.state == :active
 
-        definition = prepare_plugin_definition(plugin_meta)
+        definition = prepare_plugin_definition(plugin_meta, content: content)
         return false unless definition
 
+        unload_plugin(name, runtime_manager: runtime_manager) if already_running
+        Rubik::Plugin::Registry.register(definition)
+
         fiber = register_plugin_component(name, definition, plugin_meta, runtime_manager: runtime_manager)
-        return false unless fiber
+        if fiber.nil? || fiber.state == :failed || (was_active && fiber.state == :pending)
+          if already_running && previous_def
+            @logger.error("Failed to activate replacement for plugin '#{name}' (state: #{fiber&.state}); rolling back to previous version")
+            runtime_manager.unregister_component(component_name)
+            restore_previous_plugin(name, previous_def, plugin_meta, runtime_manager: runtime_manager)
+          end
+          return false
+        end
 
-        # Honest load result (issue #144): a failed activation (factory raised)
-        # is reported as failure, not as a successful load.
         fiber.state != :failed
       end
 
@@ -159,14 +173,19 @@ module Rubik
           return false
         end
 
-        integrity = storage.verify_integrity(target[:path], scope: target[:scope])
+        content = File.exist?(target[:path]) ? File.binread(target[:path]) : nil
+        integrity = storage.verify_integrity(target[:path], scope: target[:scope], content: content)
         if integrity == :rejected
           @logger.error("Reload of drop-in plugin '#{name}' refused: integrity check failed; previous version kept")
           return false
         end
 
+        component_name = "plugin_#{name}"
         previous = Rubik::Plugin::Registry.get(name)
-        definition = prepare_plugin_definition(target)
+        previous_fiber = runtime_manager.fibers[component_name]
+        was_active = previous_fiber&.state == :active
+
+        definition = prepare_plugin_definition(target, content: content)
         unless definition
           @logger.error("Reload of drop-in plugin '#{name}' failed during preparation; previous version kept")
           return false
@@ -175,10 +194,11 @@ module Rubik
         unload_plugin(name, runtime_manager: runtime_manager)
         Rubik::Plugin::Registry.register(definition)
         fiber = register_plugin_component(name, definition, target, runtime_manager: runtime_manager)
-        return true if fiber && fiber.state != :failed
+        return true if fiber && fiber.state != :failed && (!was_active || fiber.state == :active)
 
-        @logger.error("Reload of drop-in plugin '#{name}' failed during activation; rolling back")
-        runtime_manager.unregister_component("plugin_#{name}")
+        state_reason = fiber ? fiber.state.to_s : "nil fiber"
+        @logger.error("Reload of drop-in plugin '#{name}' failed during activation (ended #{state_reason}); rolling back")
+        runtime_manager.unregister_component(component_name)
         restore_previous_plugin(name, previous, target, runtime_manager: runtime_manager)
         false
       end
@@ -190,7 +210,7 @@ module Rubik
       # replacement can never cost the old version. Returns the new
       # Definition on success; nil on failure, with the previous registry
       # entry restored and the load-path claim released.
-      def prepare_plugin_definition(plugin_meta)
+      def prepare_plugin_definition(plugin_meta, content: nil)
         name = plugin_meta[:name]
         path = plugin_meta[:path]
         load_path = plugin_meta[:load_path]
@@ -199,7 +219,11 @@ module Rubik
         claim_load_path(load_path)
 
         begin
-          load path
+          if content
+            TOPLEVEL_BINDING.eval(content, path)
+          else
+            load path
+          end
         rescue StandardError, ScriptError => e
           @logger.error("Failed to parse drop-in plugin '#{name}': #{e.message}")
           rollback_prepared_definition(name, previous)

data/lib/rubik/plugin/package_inventory.rb

@@ -33,12 +33,22 @@ module Rubik
         e.message
       end
 
+      def secure_compare(first, second)
+        return false unless first.is_a?(String) && second.is_a?(String)
+        return false unless first.bytesize == second.bytesize
+
+        bytes = first.unpack("C*")
+        res = 0
+        second.each_byte { |byte| res |= byte ^ bytes.shift }
+        res.zero?
+      end
+
       # Audits additions, deletions, and modifications: any drift means the
       # package no longer matches the consented inventory.
       def drift(expected, current)
         added = current.keys - expected.keys
         removed = expected.keys - current.keys
-        modified = (current.keys & expected.keys).reject { |f| current[f] == expected[f] }
+        modified = (current.keys & expected.keys).reject { |f| secure_compare(current[f], expected[f]) }
 
         parts = []
         parts << "added: #{added.sort.join(', ')}" unless added.empty?

data/lib/rubik/plugin/storage.rb

@@ -6,6 +6,7 @@ require "time"
 # save_manifest atomik yazımı Platform.atomic_write kullanır; dosyanın tek başına
 # require edilmesi durumunda da çözümlenebilsin diye açık yüklenir.
 require_relative "../platform"
+require_relative "../log"
 require_relative "package_inventory"
 
 module Rubik
@@ -31,7 +32,7 @@ module Rubik
         [project_plugins_dir, global_plugins_dir].each do |dir|
           FileUtils.mkdir_p(dir)
         rescue SystemCallError => e
-          warn "[WARN] Failed to create plugin directory #{dir}: #{e.message}" if ENV["RUBIK_DEBUG"]
+          Rubik::Log.warn(:plugin, "Failed to create plugin directory #{dir}: #{e.class}: #{e.message}")
         end
       end
 
@@ -67,7 +68,7 @@ module Rubik
         save_manifest(dir, manifest)
       end
 
-      def verify_integrity(path, scope: :project)
+      def verify_integrity(path, scope: :project, content: nil)
         return :trusted if ENV["RUBIK_TRUST_OVERLAYS"] == "1"
 
         dir = scope.to_sym == :global ? global_plugins_dir : project_plugins_dir
@@ -78,12 +79,12 @@ module Rubik
         basename = File.basename(path)
         manifest = load_manifest(dir)
 
-        current_content = File.exist?(path) ? File.binread(path) : ""
+        current_content = content || (File.exist?(path) ? File.binread(path) : "")
         current_hash = PackageInventory.content_hash(current_content)
 
         if manifest.key?(basename)
           expected_hash = manifest[basename]["sha256"]
-          if current_hash == expected_hash
+          if PackageInventory.secure_compare(current_hash, expected_hash)
             :verified
           else
             warn "[SECURITY] Integrity check failed for plugin '#{basename}': file modified since adding."

data/lib/rubik/repair/loop.rb

@@ -27,20 +27,34 @@ module Rubik
 
           @snapshot_store.create_snapshot(@buffer_manager)
 
-          prompt = build_repair_prompt(current_diag, target_file, @attempts_made)
-          res = @provider.complete([{ role: "user", content: prompt }])
-          proposed_code = extract_code(res.text)
-
-          @buffer_manager.write(target_file, proposed_code)
-
-          # Verify syntax against in-memory buffer via tempfile
-          check_res = check_buffer_syntax(target_file, lang)
-
-          return { ok: true, attempts: @attempts_made, code: proposed_code } if check_res[:ok]
-
-          current_diag = Rubik::Diagnostics::Parser.parse(check_res[:output], lang)
-          @snapshot_store.undo(@buffer_manager)
-
+          begin
+            prompt = build_repair_prompt(current_diag, target_file, @attempts_made)
+            res = @provider.complete([{ role: "user", content: prompt }])
+            proposed_code = extract_code(res.text)
+
+            if proposed_code.empty?
+              @snapshot_store.undo(@buffer_manager)
+              next
+            end
+
+            @buffer_manager.write(target_file, proposed_code)
+
+            # Verify syntax against in-memory buffer via tempfile
+            check_res = check_buffer_syntax(target_file, lang)
+
+            return { ok: true, attempts: @attempts_made, code: proposed_code } if check_res[:ok]
+
+            if check_res[:unverified]
+              @snapshot_store.undo(@buffer_manager)
+              return { ok: false, attempts: @attempts_made, unverified: true, error: check_res[:error] }
+            end
+
+            current_diag = Rubik::Diagnostics::Parser.parse(check_res[:output], lang)
+            @snapshot_store.undo(@buffer_manager)
+          rescue StandardError => e
+            @snapshot_store.undo(@buffer_manager)
+            return { ok: false, attempts: @attempts_made, error: "#{e.class}: #{e.message}" }
+          end
         end
 
         { ok: false, attempts: @attempts_made, last_diagnostics: current_diag }
@@ -50,7 +64,7 @@ module Rubik
 
       def check_buffer_syntax(target_file, lang)
         adapter = @adapter_registry.get(lang.to_s)
-        return { ok: true } unless adapter
+        return { ok: false, unverified: true, error: "No adapter registered for #{lang}" } unless adapter
 
         content = @buffer_manager.read(target_file)
         ext = File.extname(target_file)

data/lib/rubik/storage/vakanuvis/vocabulary.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "digest"
+
 module Rubik
   module Storage
     module Vakanuvis
@@ -36,16 +38,45 @@ module Rubik
 
         module_function
 
+        def transliterate(text)
+          s = text.to_s.dup
+          s.gsub!(/[çÇ]/, "c")
+          s.gsub!(/[ğĞ]/, "g")
+          s.gsub!(/[ıİ]/, "i")
+          s.gsub!(/[öÖ]/, "o")
+          s.gsub!(/[şŞ]/, "s")
+          s.gsub!(/[üÜ]/, "u")
+          s.unicode_normalize(:nfd).gsub(/\p{M}/, "")
+        end
+
         # Deterministik slug: aynı metin ⇒ aynı slug ⇒ aynı ref (digest
         # makbuzlarının ve mem./wiki. ref'lerin yeniden oynatılabilirliği
         # buna dayanır). Yalnızca-rakam slug'a "n" öneki zorunlu: Store'un
         # çözümleyicisi "wiki.42" gibi iki parçalı tip.satır formlarını ref
         # alias'tan ÖNCE dener — çarpışma yanlış satırı ezmesi demekti.
+        # Unicode dönüştürme ve kısaltma/boşluk durumunda deterministik
+        # hash eki (issue #269) çakışmaları önler.
         def slug(text)
-          s = text.to_s.downcase.gsub(/[^a-z0-9]+/, "-")
+          raw = text.to_s
+          return "untitled" if raw.strip.empty?
+
+          trans = transliterate(raw)
+          lossy = trans.match?(/[^\x00-\x7F]/)
+
+          s = trans.downcase.gsub(/[^a-z0-9]+/, "-")
           s = s.delete_prefix("-") while s.start_with?("-")
           s = s.delete_suffix("-") while s.end_with?("-")
-          s = s[0, SLUG_MAX].to_s
+
+          hash = Digest::SHA256.hexdigest(raw)[0, 6]
+
+          return "untitled-#{hash}" if s.empty?
+
+          if s.length > SLUG_MAX || lossy
+            prefix = s[0, SLUG_MAX - 7].to_s
+            prefix = prefix.delete_suffix("-") while prefix.end_with?("-")
+            s = prefix.empty? ? "untitled-#{hash}" : "#{prefix}-#{hash}"
+          end
+
           s = s.delete_suffix("-") while s.end_with?("-")
           s = "n#{s}" if s.match?(/\A\d+\z/)
           s.empty? ? "untitled" : s