rubik 0.4.0 → 0.4.2

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

@@ -21,8 +21,7 @@ module Rubik
           type: "object",
           properties: {
             reason: { type: "string", description: "Optional explanation of why buffer is being applied (e.g. 'prior to running tests')" },
-            force: { type: "boolean",
-                     description: "If true, overwrites disk files even if modified externally by formatters (resolves [CONFLICT])" }
+            force: { type: "boolean", description: "If true, overwrites disk files even if modified externally by formatters (resolves [CONFLICT])" }
           }
         }
       )
@@ -42,8 +41,7 @@ module Rubik
                                   "(buffer.model_can_apply: false). The human operator will review and apply changes.")
         end
 
-        force = [true, "true"].include?(args["force"]) || [true, "true"].include?(args[:force]) ||
-                [true, "true"].include?(args["overwrite"]) || [true, "true"].include?(args[:overwrite])
+        force = [args["force"], args[:force], args["overwrite"], args[:overwrite]].intersect?([true, "true"])
         policy = force ? "overwrite" : nil
 
         if @buffer_manager.dirty?
@@ -66,16 +64,24 @@ module Rubik
                         "To force overwrite with your buffer changes, call: apply_buffer(force: true)\n" \
                         "Call read_file(path: \"#{c}\", reload: true) to inspect external changes or resolve."
           end
+          skipped = @buffer_manager.respond_to?(:last_skipped) ? (@buffer_manager.last_skipped || []) : []
+          skipped.each do |s|
+            path = s.is_a?(Hash) ? s[:path] : s.to_s
+            reason = s.is_a?(Hash) ? s[:reason] : "invalid path"
+            messages << "[SKIPPED] #{path}: discarded as invalid path (#{reason}) and NOT written to disk."
+          end
 
-          if applied.empty? && !conflicts.empty?
-            ToolOutput.error(messages.join("\n"))
-          elsif applied.empty?
-            # Inside the dirty? branch with zero applies and zero conflicts,
-            # every buffered entry was discarded as an invalid path
-            # (apply!'s garbage-skip) — the edits are NOT on disk, and citing
-            # an earlier apply here would be a lie.
-            "No unapplied buffer changes to write: the buffered entries were discarded as invalid paths and are NOT on disk. " \
-              "Re-check the target paths and buffer them again."
+          if applied.empty?
+            if conflicts.empty? && skipped.empty?
+              # Inside the dirty? branch with zero applies and zero conflicts,
+              # every buffered entry was discarded as an invalid path
+              # (apply!'s garbage-skip) — the edits are NOT on disk, and citing
+              # an earlier apply here would be a lie.
+              "No unapplied buffer changes to write: the buffered entries were discarded as invalid paths and are NOT on disk. " \
+                "Re-check the target paths and buffer them again."
+            else
+              ToolOutput.error(messages.join("\n"))
+            end
           else
             messages.join("\n")
           end
@@ -102,31 +108,18 @@ module Rubik
         params_schema: {
           type: "object",
           properties: {
-            target: {
-              type: "string",
-              enum: ["lsp", "test_runner", "linter", "command"],
-              description: "Runtime component type to repair or adapt"
-            },
-            language_or_type: {
-              type: "string",
-              description: "Language or service identifier (e.g., 'ruby', 'python', 'rust', 'go', 'zig', 'c', 'bash')"
-            },
+            target: { type: "string", enum: ["lsp", "test_runner", "linter", "command"], description: "Runtime component type to repair or adapt" },
+            language_or_type: { type: "string", description: "Language or service identifier (e.g., 'ruby', 'python', 'rust', 'go', 'zig', 'c', 'bash')" },
             proposed_command: {
               oneOf: [{ type: "string" },
-                      { type: "object", properties: { executable: { type: "string" },
-                                                      args: { type: "array", items: { type: "string" } } },
+                      { type: "object", properties: { executable: { type: "string" }, args: { type: "array", items: { type: "string" } } },
                         required: ["executable", "args"], additionalProperties: false },
                       { type: "array", items: { type: "string" }, minItems: 1 }],
               description: "Replacement command: a legacy string or, for LSP, {executable, args} / argv array. Omit to probe automatically."
             },
-            probe_args: {
-              type: "array", items: { type: "string" },
-              description: "Explicit non-mutating functional probe arguments appended to the exact proposed command; required for unknown executables"
-            },
-            auto_probe: {
-              type: "boolean",
-              description: "Whether to automatically probe system binaries and candidate commands (default: true)"
-            }
+            probe_args: { type: "array", items: { type: "string" },
+                          description: "Explicit non-mutating probe arguments appended to proposed command; required for unknown executables" },
+            auto_probe: { type: "boolean", description: "Whether to automatically probe system binaries and candidate commands (default: true)" }
           },
           required: ["target", "language_or_type"]
         }
@@ -154,25 +147,17 @@ module Rubik
         else
           proposed_cmd = raw_command.to_s.strip
         end
-        auto_probe = if args["auto_probe"].nil?
-                       args[:auto_probe].nil? || args[:auto_probe]
-                     else
-                       args["auto_probe"]
-                     end
+        auto_probe = args.fetch("auto_probe", args.fetch(:auto_probe, true))
 
         return ToolOutput.error("Target and language_or_type must be provided.") if target.empty? || lang.empty?
 
         # 1. Automatic Probing if proposed_cmd is not specified or auto_probe is requested
         if !command_provided?(proposed_cmd) && auto_probe
           candidate = case target
-                      when "lsp"
-                        Rubik::Runtime::Discovery.probe_lsp(lang, root_dir: @root_dir)
-                      when "test_runner"
-                        Rubik::Runtime::Discovery.discover_test_runners(root_dir: @root_dir, lang: lang).first
-                      when "linter"
-                        Rubik::Runtime::Discovery.discover_formatters(root_dir: @root_dir, lang: lang).first
-                      when "command"
-                        Rubik::Runtime::Discovery.binary_available?(lang) ? lang : nil
+                      when "lsp" then Rubik::Runtime::Discovery.probe_lsp(lang, root_dir: @root_dir)
+                      when "test_runner" then Rubik::Runtime::Discovery.discover_test_runners(root_dir: @root_dir, lang: lang).first
+                      when "linter" then Rubik::Runtime::Discovery.discover_formatters(root_dir: @root_dir, lang: lang).first
+                      when "command" then Rubik::Runtime::Discovery.binary_available?(lang) ? lang : nil
                       end
 
           if candidate
@@ -232,8 +217,18 @@ module Rubik
             @repair_scopes.delete([root_ctx, service_key]) if @repair_scopes[[root_ctx, service_key]].equal?(promotion_ctx)
             unless root_ctx.disposed?
               if previous_services.key?(service_key)
-                restored = target == "lsp" ? @lsp_manager&.clients&.[](lang) : nil
-                root_ctx.provide(service_key, restored || previous_services[service_key])
+                if target == "lsp"
+                  restored = @lsp_manager&.clients&.[](lang)
+                  active = restored && (!restored.respond_to?(:alive?) || restored.alive?) &&
+                           (!restored.respond_to?(:running?) || restored.running?)
+                  if active
+                    root_ctx.provide(service_key, restored)
+                  else
+                    root_ctx.unprovide(service_key)
+                  end
+                else
+                  root_ctx.provide(service_key, previous_services[service_key])
+                end
               else
                 root_ctx.unprovide(service_key)
               end

data/lib/rubik/ui/capability.rb

@@ -10,12 +10,14 @@ module Rubik
     # Resolution order:
     #   1. RUBIK_TEST=1                     -> never (deterministic test output)
     #   2. NO_COLOR set                     -> never (https://no-color.org)
-    #   3. CLICOLOR_FORCE=1                 -> always (CI with color-capable logs)
+    #   3. CLICOLOR_FORCE set (not 0/false) -> always (CI with color-capable logs)
     #   4. ui.color config: always|never    -> explicit override
     #   5. output not a TTY                 -> never (pipe/redirect safety)
     #   6. TERM=dumb                        -> never
     #   7. Windows legacy conhost           -> try enabling VT, else never
     module Capability
+      FALSY_ENV_VALUES = ["0", "false", "no", "off"].freeze
+
       module_function
 
       # Strips ANSI SGR escape sequences from a string. Used on the recording
@@ -31,13 +33,16 @@ module Rubik
         case resolve_mode(io, config)
         when :always then true
         when :never then false
-        else io.respond_to?(:tty?) ? io.tty? : false
+        else
+          real_io = unwrap_tee(io)
+          real_io.respond_to?(:tty?) ? real_io.tty? : false
         end
       end
 
       # True when the target can animate a spinner line (real terminal only).
       def spinner?(io, config = nil)
-        color?(io, config) && io.respond_to?(:tty?) && io.tty? && interactive_env?
+        real_io = unwrap_tee(io)
+        color?(io, config) && real_io.respond_to?(:tty?) && real_io.tty? && interactive_env?
       end
 
       def interactive_env?
@@ -68,17 +73,26 @@ module Rubik
         io.targets.compact.find(&:tty?)
       end
 
+      def clicolor_force?
+        val = ENV.fetch("CLICOLOR_FORCE", nil)
+        return false if val.nil? || val.empty?
+
+        !FALSY_ENV_VALUES.include?(val.downcase)
+      end
+
       def resolve_mode(io, config)
         return :never if ENV["RUBIK_TEST"] == "1"
         return :never if ENV["NO_COLOR"] && !ENV["NO_COLOR"].to_s.empty?
-        return :always if ENV["CLICOLOR_FORCE"] && ENV["CLICOLOR_FORCE"].to_s == "1"
+        return :always if clicolor_force?
 
         cfg_mode = config&.fetch("ui.color", "auto").to_s.downcase if config
         return :always if cfg_mode == "always"
         return :never if cfg_mode == "never"
 
         return :never if ENV["TERM"] && ENV["TERM"].downcase == "dumb"
-        return :never unless io.respond_to?(:tty?) && io.tty?
+
+        real_io = unwrap_tee(io)
+        return :never unless real_io.respond_to?(:tty?) && real_io.tty?
 
         enable_windows_virtual_terminal_if_needed
         :auto

data/lib/rubik/ui/renderer.rb

@@ -172,6 +172,7 @@ module Rubik
       def render_llm_thought(step_info)
         @spinner.stop
         return nil if level < Rubik::REPL::StepFormatter::LEVEL_VERBOSE
+        return nil if step_info[:streamed] == true
 
         first_line = @legacy.thought_first_line(step_info[:content])
         return nil if first_line.nil? || first_line.empty?

data/lib/rubik/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubik
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.2
 platform: ruby
 authors:
 - Özgür Ulukır