rubik 0.1.0

data/lib/rubik/repl/step_formatter.rb

@@ -0,0 +1,324 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../platform"
+
+module Rubik
+  module REPL
+    class StepFormatter
+      LEVEL_QUIET   = 0
+      LEVEL_NORMAL  = 1
+      LEVEL_VERBOSE = 2
+      LEVEL_DEBUG   = 3
+
+      # Canonical argument keys considered the "primary" operand of a tool
+      # call, shared with UI::Renderer (Plan 51, Decision D2).
+      PRIMARY_ARG_KEYS = ["path", "file", "target_file", "filename", "command", "cmd", "query", "pattern", "message", "code", "url", "name", "role",
+                          "input"].freeze
+
+      attr_reader :level, :max_steps
+
+      def self.normalize_level(val)
+        case val.to_s.downcase.strip
+        when "quiet", "0" then LEVEL_QUIET
+        when "verbose", "2" then LEVEL_VERBOSE
+        when "debug", "trace", "3" then LEVEL_DEBUG
+        else LEVEL_NORMAL
+        end
+      end
+
+      def initialize(config: nil, verbosity: nil, max_steps: nil)
+        @config = config
+        @max_steps = max_steps
+        raw_verb = verbosity || config&.verbosity || "normal"
+        @level = self.class.normalize_level(raw_verb)
+      end
+
+      def verbosity
+        case @level
+        when LEVEL_QUIET then "quiet"
+        when LEVEL_VERBOSE then "verbose"
+        when LEVEL_DEBUG then "debug"
+        else "normal"
+        end
+      end
+
+      def format(step_info)
+        return nil unless step_info.is_a?(Hash)
+
+        type = step_info[:type]&.to_sym
+        case type
+        when :thinking
+          format_thinking(step_info)
+        when :tool_call
+          format_tool_call(step_info)
+        when :tool_result
+          format_tool_result(step_info)
+        when :llm_thought
+          format_llm_thought(step_info)
+        when :step_warning
+          format_step_warning(step_info)
+        when :llm_retry
+          format_llm_retry(step_info)
+        when :auto_apply
+          format_auto_apply(step_info)
+        when :emergency_compact
+          format_emergency_compact(step_info)
+        when :goal_wait
+          format_goal_wait(step_info)
+        when :finish
+          format_finish(step_info)
+        when :message
+          format_message(step_info)
+        when :chunk, :chunk_end
+          nil
+        end
+      end
+
+      def format_thinking(step_info)
+        return nil if @level == LEVEL_QUIET
+
+        parts = thinking_parts(step_info)
+        target_str = parts[:target].empty? ? "" : " (#{parts[:target]})"
+
+        case @level
+        when LEVEL_NORMAL
+          " ⏳ [Step #{parts[:step]}/#{parts[:max]}] Thinking...#{target_str}"
+        when LEVEL_VERBOSE
+          " ⏳ [Step #{parts[:step]}/#{parts[:max]}] Querying LLM#{target_str}..."
+        when LEVEL_DEBUG
+          "[DEBUG:thinking] step=#{parts[:step]}/#{parts[:max]} provider=#{step_info[:provider]} model=#{step_info[:model]}"
+        end
+      end
+
+      # Semantic decomposition shared with UI::Renderer: step budget parts
+      # and the "provider/model" target label of a :thinking event.
+      def thinking_parts(step_info)
+        step = step_info[:step] || step_info[:current] || 1
+        max = step_info[:max_steps] || step_info[:max] || @max_steps || "?"
+        target = [step_info[:provider], step_info[:model]].compact.reject { |s| s.to_s.strip.empty? }.join("/")
+        { step: step, max: max, target: target }
+      end
+
+      def summarize_primary_arg(args)
+        return "" unless args.is_a?(Hash) && !args.empty?
+
+        matched_key = PRIMARY_ARG_KEYS.find { |k| args.key?(k) || args.key?(k.to_sym) }
+
+        if matched_key
+          "#{matched_key}: #{format_arg_value(primary_arg_value(args))}"
+        else
+          k, v = args.first
+          "#{k}: #{format_arg_value(v)}"
+        end
+      end
+
+      # Raw value of the primary operand (no key prefix, no quoting) — the
+      # semantic twin of #summarize_primary_arg consumed by UI::Renderer.
+      def primary_arg_value(args)
+        return "" unless args.is_a?(Hash) && !args.empty?
+
+        matched_key = PRIMARY_ARG_KEYS.find { |k| args.key?(k) || args.key?(k.to_sym) }
+        key = matched_key || args.first[0]
+        args.key?(key) ? args[key] : args[key.to_sym]
+      end
+
+      def format_arg_value(val)
+        val.is_a?(String) ? "\"#{truncate_str(val, 50)}\"" : val.to_s
+      end
+
+      def summarize_result(output, step_info = {})
+        return step_info[:summary] if step_info[:summary] && !step_info[:summary].to_s.empty?
+
+        lines = output.to_s.lines
+        if lines.empty?
+          "ok"
+        elsif lines.size > 1
+          "#{lines.size} lines"
+        else
+          line = lines.first.strip
+          line.length > 60 ? "#{line[0..57]}..." : line
+        end
+      end
+
+      # First printable line of an assistant thought with fenced JSON tool
+      # blocks stripped; nil when nothing human-readable remains. Shared
+      # with UI::Renderer (Plan 51, Decision D2).
+      def thought_first_line(content)
+        clean_content = content.to_s.sub(/```(?:json)?\s*\{.*?\}\s*```/m, "").strip
+        return nil if clean_content.empty?
+
+        clean_content.lines.first.to_s.strip
+      end
+
+      private
+
+      def truncate_str(str, max_len = 50)
+        return str if str.length <= max_len
+
+        "#{str[0...(max_len - 3)]}..."
+      end
+
+      def format_tool_call(step_info)
+        return nil if @level == LEVEL_QUIET
+
+        step = step_info[:step] || step_info[:current] || 1
+        max = step_info[:max_steps] || step_info[:max] || @max_steps || "?"
+        tool = step_info[:tool]
+        args = step_info[:args] || {}
+        call_id = step_info[:call_id]
+
+        case @level
+        when LEVEL_NORMAL
+          summary = summarize_primary_arg(args)
+          if summary.empty?
+            " ▶ [Step #{step}/#{max}] #{tool}"
+          else
+            " ▶ [Step #{step}/#{max}] #{tool} (#{summary})"
+          end
+        when LEVEL_VERBOSE
+          " ▶ [Step #{step}/#{max}] Calling #{tool} with args: #{Rubik::Platform.safe_json_generate(args)}"
+        when LEVEL_DEBUG
+          "[DEBUG:tool_call] step=#{step}/#{max} tool=#{tool} call_id=#{call_id} args=#{Rubik::Platform.safe_json_generate(args)}"
+        end
+      end
+
+      def format_tool_result(step_info)
+        return nil if @level == LEVEL_QUIET
+
+        tool = step_info[:tool]
+        status = (step_info[:status] || :ok).to_sym
+        duration_ms = step_info[:duration_ms] || 0.0
+        output = step_info[:output].to_s
+
+        case @level
+        when LEVEL_NORMAL
+          if status == :ok
+            summary_line = summarize_result(output, step_info)
+            " ✔ [Obs] #{summary_line} (#{duration_ms}ms)"
+          else
+            err = step_info[:error]
+            err = output.lines.first.to_s.strip if err.nil? || err.empty?
+            err = "Command failed" if err.empty?
+            if err.start_with?("Security blocked:") || output.start_with?("Security blocked:")
+              sec_line = output.lines.first.to_s.strip
+              hint = output[/!(?:allow-cmd|allow-dir)\s+[^\n]+/]&.strip
+              msg = hint ? "#{sec_line} [#{hint}]" : sec_line
+              " ⚠ [Security] #{msg}"
+            else
+              " ✖ [Error] #{err} (#{duration_ms}ms)"
+            end
+          end
+        when LEVEL_VERBOSE
+          lines_size = step_info[:line_count] || output.lines.size
+          byte_size = step_info[:byte_size] || output.bytesize
+          if status == :ok
+            header = " ✔ [Obs] #{lines_size} lines (#{byte_size} B, #{duration_ms}ms)"
+          else
+            err = step_info[:error]
+            err = output.lines.first.to_s.strip if err.nil? || err.empty?
+            err = "Command failed" if err.empty?
+            if err.start_with?("Security blocked:") || output.start_with?("Security blocked:")
+              sec_line = output.lines.first.to_s.strip
+              hint = output[/!(?:allow-cmd|allow-dir)\s+[^\n]+/]&.strip
+              msg = hint ? "#{sec_line} [#{hint}]" : sec_line
+              return " ⚠ [Security] #{msg}"
+            end
+            header = " ✖ [Error] #{err} (#{duration_ms}ms)"
+          end
+
+          if output.empty?
+            header
+          else
+            preview = output.lines.first(5).map { |l| "     #{l.chomp}" }.join("\n")
+            "#{header}\n   ↳ Preview:\n#{preview}"
+          end
+        when LEVEL_DEBUG
+          "[DEBUG:tool_result] tool=#{tool} status=#{status} duration=#{duration_ms}ms\n#{output}"
+        end
+      end
+
+      # First printable line of an assistant thought with fenced JSON tool
+      # blocks stripped; nil when nothing human-readable remains. Shared
+      # with UI::Renderer (Plan 51, Decision D2).
+      def format_llm_thought(step_info)
+        return nil if @level == LEVEL_QUIET || @level == LEVEL_NORMAL
+
+        first_line = thought_first_line(step_info[:content])
+        return nil if first_line.nil? || first_line.empty?
+
+        " 💭 [Thought] #{first_line}"
+      end
+
+      def format_step_warning(step_info)
+        current = step_info[:current] || step_info[:step]
+        max = step_info[:max] || step_info[:max_steps] || @max_steps
+        remaining = step_info[:remaining] || (max && current ? (max.to_i - current.to_i) : 0)
+        " ⚠️ [Rubik::Agent] Step budget warning: #{current}/#{max} steps used (#{remaining} remaining)."
+      end
+
+      def format_llm_retry(step_info)
+        return nil if @level == LEVEL_QUIET
+
+        attempt = step_info[:attempt] || "?"
+        max = step_info[:max] || "?"
+        reason = step_info[:reason].to_s
+        if @level == LEVEL_DEBUG
+          "[DEBUG:llm_retry] step=#{step_info[:step] || '?'}/#{step_info[:max_steps] || '?'} retry=#{attempt}/#{max} reason=#{reason}"
+        else
+          " ↻ [Rubik::LLM] retry #{attempt}/#{max} (#{reason})"
+        end
+      end
+
+      def format_auto_apply(step_info)
+        return nil if @level == LEVEL_QUIET
+
+        files = step_info[:files] || []
+        " ⚡ [Rubik::Buffer] Auto-applied #{files.size} modified file(s) to disk: #{files.join(', ')}"
+      end
+
+      def format_emergency_compact(_step_info)
+        " ⚠️ [Rubik::Context] Context overflow auto-recovery: applied emergency compaction to history."
+      end
+
+      # Goal-mode implicit wait (GoalWait): the run is holding itself open
+      # on live subagents instead of accepting a premature completion.
+      def format_goal_wait(step_info)
+        return nil if @level == LEVEL_QUIET
+
+        timeout = step_info[:timeout]
+        wait_note = timeout.to_i.positive? ? "waiting up to #{timeout}s" : "no blocking wait (agent.goal_wait_timeout=0)"
+        " ⏳ [Rubik::Goal] #{step_info[:active]} subagent(s) still active — goal held open (#{wait_note})."
+      end
+
+      # The full answer is rendered exactly once elsewhere (live chunks or
+      # the post-loop markdown render); this header stays to ONE line so the
+      # whole text is never printed twice. The suffix must tell the truth
+      # about WHERE the content went: streamed turns show "(+N more lines)"
+      # — the text is already above; batch turns say "(full answer below)"
+      # because the post-loop render follows immediately. A missing :streamed
+      # key defaults to streamed (the dominant interactive path).
+      def format_finish(step_info)
+        return nil if @level == LEVEL_QUIET
+
+        message = (step_info[:message] || "Completed").to_s.strip
+        return " 🏁 [Rubik::Agent] Completed" if message.empty?
+
+        streamed = step_info.key?(:streamed) ? step_info[:streamed] == true : true
+        return " 🏁 [Rubik::Agent] Completed (full answer below)" unless streamed
+
+        lines = message.lines
+        first = lines.first.to_s.strip
+        suffix = lines.count > 1 ? " (+#{lines.count - 1} more lines)" : ""
+        " 🏁 [Rubik::Agent] Completed: #{first}#{suffix}"
+      end
+
+      def format_message(step_info)
+        return nil if @level == LEVEL_QUIET || @level == LEVEL_NORMAL || @level == LEVEL_VERBOSE
+
+        content = step_info[:content]
+        "[DEBUG:message] #{content}"
+      end
+    end
+  end
+end

data/lib/rubik/repl/tee_io.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative "../ui/capability"
+
+module Rubik
+  module REPL
+    class TeeIO
+      attr_reader :targets
+
+      def initialize(*targets)
+        @targets = targets.compact
+      end
+
+      def string_io?
+        @targets.any?(StringIO)
+      end
+
+      # Public predicate for test capture detection. Returns true when
+      # the TeeIO is being used to capture output into a StringIO
+      # buffer (typically in tests). The Shell and agent commands
+      # use this to short-circuit interactive yes/no prompts to
+      # "no" without inspecting the implementation details.
+      def test_capture?
+        string_io? || @targets.empty?
+      end
+
+      def puts(*args)
+        dispatch(:puts, args)
+      end
+
+      def print(*args)
+        dispatch(:print, args)
+      end
+
+      def printf(*args)
+        dispatch(:printf, args)
+      end
+
+      # Writes data to all underlying IO targets simultaneously.
+      # StringIO targets (session capture, conversation recording) receive
+      # ANSI-stripped content so recordings and LLM context stay clean.
+      #
+      # @param args [Array<String>] one or more strings to write
+      # @return [void]
+      def write(*args)
+        dispatch(:write, args)
+      end
+
+      def flush
+        ordered_targets.each do |target|
+          target.flush if target.respond_to?(:flush)
+        rescue StandardError => e
+          drop_failed_target(target, :flush, e)
+        end
+        nil
+      end
+
+      # Returns "" by design when every recorder has been detached by the
+      # failure policy — a degraded transcript, never a raise.
+      def string
+        target = @targets.find { |t| t.respond_to?(:string) }
+        target&.string || ""
+      end
+
+      def reopen(*)
+        @targets.each { |t| t.reopen(*) if t.respond_to?(:reopen) }
+      end
+
+      private
+
+      # User-facing streams first, recorders (StringIO captures) last: the
+      # recorder must survive a dead user stream and keep its copy of the
+      # transcript. Ordering only affects failure isolation — tee semantics
+      # deliver identical bytes to every target either way.
+      def ordered_targets
+        recorders, users = @targets.partition { |t| t.is_a?(StringIO) }
+        users + recorders
+      end
+
+      def dispatch(method, args)
+        ordered_targets.each do |target|
+          if target.is_a?(StringIO)
+            target.public_send(method, *strip_args(args))
+          else
+            target.public_send(method, *args)
+          end
+        rescue StandardError => e
+          # One broken target (closed pipe, EPIPE) must never kill the tee:
+          # warn once, detach it, keep the remaining targets — the recorder
+          # keeps its copy even when the user stream dies.
+          drop_failed_target(target, method, e)
+        end
+      end
+
+      def drop_failed_target(target, method, exception)
+        @targets.delete(target)
+        warn "[rubik] tee target failed during ##{method} (#{exception.class}: #{exception.message}); detached from output"
+      end
+
+      def strip_args(args)
+        args.map { |a| a.is_a?(String) ? Rubik::UI::Capability.strip_ansi(a) : a }
+      end
+    end
+  end
+end

data/lib/rubik/repl/terminal_guard.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module Rubik
+  module REPL
+    # Guard protecting Reline input buffer and screen from asynchronous background notices (Plan 105).
+    # When Reline is actively reading, notices clear the current line (\r\e[2K), print cleanly,
+    # and call Reline.redisplay to restore the prompt and in-progress user input buffer.
+    # When idle, notices are output directly. Supports quiet inbox buffering.
+    class TerminalGuard
+      include MonitorMixin
+
+      attr_accessor :quiet, :output, :reline
+
+      def initialize(output: $stdout, reline: Reline, quiet: false)
+        super()
+        @output = output
+        @reline = reline
+        @quiet = quiet
+        @reading = false
+        @collecting = false
+        @inbox = []
+      end
+
+      def reading?
+        synchronize { @reading }
+      end
+
+      def with_reading
+        synchronize { @reading = true }
+        yield
+      ensure
+        synchronize { @reading = false }
+      end
+
+      def print_safe_notice(text, force: false)
+        return false if text.nil? || text.to_s.empty?
+
+        clean_text = text.to_s.sub(/\A\n+/, "")
+
+        synchronize do
+          if @quiet && !force
+            @inbox << clean_text
+            return false
+          end
+
+          if @reading
+            @output.print "\r\e[2K"
+            @output.puts clean_text
+            redisplay_cleanly
+          else
+            @output.puts clean_text
+          end
+          @output.flush if @output.respond_to?(:flush)
+          true
+        end
+      end
+
+      def quiet?
+        synchronize { @quiet }
+      end
+
+      def inbox
+        synchronize { @inbox.dup }
+      end
+
+      def flush_inbox!
+        synchronize do
+          items = @inbox.dup
+          @inbox.clear
+          items
+        end
+      end
+
+      def flush_notices!
+        items = flush_inbox!
+        return false if items.empty?
+
+        synchronize do
+          if @reading
+            @output.print "\r\e[2K"
+            items.each { |item| @output.puts item }
+            redisplay_cleanly
+          else
+            items.each { |item| @output.puts item }
+          end
+          @output.flush if @output.respond_to?(:flush)
+        end
+        true
+      end
+
+      # Plan 109: true when Reline is blocked reading AND the in-progress
+      # line is empty — the only state where an injected Enter submits an
+      # EMPTY line and cannot truncate user typing. respond_to? guards
+      # follow the redisplay_cleanly pattern: a double without
+      # line_buffer cannot prove emptiness, so it reads as "not idle"
+      # (never wake).
+      def idle_and_empty?
+        synchronize do
+          return false unless @reading
+          return false unless @reline.respond_to?(:line_buffer)
+
+          @reline.line_buffer.to_s.strip.empty?
+        end
+      end
+
+      # Plan 109: wake a blocked empty readline by injecting an Enter.
+      # Reline 0.7.0's IO gates (ANSI/Windows/Dumb) all poll and re-check
+      # their ungetc buffer (10ms/100ms/100ms), so the injection reaches
+      # the blocked reader on every gate. idle_and_empty? is re-evaluated
+      # inside this critical section (Monitor reentrancy makes the nested
+      # synchronize free); the residual window between check and gate
+      # consumption is inherent to Reline's thread model and accepted. A
+      # failing ungetc degrades to false — never raises into the kworker.
+      # with_reading never holds this monitor during readline, so this
+      # cannot deadlock with the reader.
+      def safe_wakeup!
+        synchronize do
+          return false if @collecting
+          return false unless idle_and_empty?
+          return false unless @reline.respond_to?(:ungetc)
+
+          begin
+            @reline.ungetc("\n".ord)
+          rescue StandardError
+            return false
+          end
+          true
+        end
+      end
+
+      # Plan 109: paste collectors (explicit !paste block, paste-burst
+      # join) set this so a reactive wake can never inject a blank Enter
+      # into the user's pasted text — the wake defers to the next regular
+      # prompt instead.
+      def with_collecting
+        synchronize { @collecting = true }
+        yield
+      ensure
+        synchronize { @collecting = false }
+      end
+
+      private
+
+      def redisplay_cleanly
+        if @reline.respond_to?(:line_editor) && @reline.line_editor
+          le = @reline.line_editor
+          le.send(:clear_rendered_screen_cache) if le.respond_to?(:clear_rendered_screen_cache, true)
+        end
+        @reline.redisplay if @reline.respond_to?(:redisplay)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end