rubik 0.1.0

data/lib/rubik/ui/diff_viewer.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Rubik
+  module UI
+    # Colorized unified-diff viewer for `!diff`: added/removed lines carry a
+    # color-blind safe cyan/red pair (never green-vs-red), hunk headers blue.
+    # The +/- signs stay in the text, so color is never the only channel.
+    # On interactive consoles a follow-up single-keypress menu offers apply.
+    # Non-TTY runs keep the plain diff byte-for-byte (tests, pipes, session
+    # replay).
+    module DiffViewer
+      module_function
+
+      def render(shell, theme, diff_text)
+        return if diff_text.to_s.empty?
+
+        require_relative "../security/redactor" unless defined?(Rubik::Security::Redactor)
+        clean_diff = Rubik::Security::Redactor.redact(diff_text.to_s)
+
+        if theme.color?
+          shell.output.puts colorize(clean_diff, theme)
+        else
+          shell.output.puts clean_diff
+        end
+
+        offer_actions(shell, theme) if interactive?(shell)
+      end
+
+      def colorize(diff_text, theme)
+        diff_text.lines.map do |line|
+          stripped = line.chomp
+          styled =
+            if stripped.start_with?("+++", "---", "===")
+              theme.paint(stripped, :bold)
+            elsif stripped.start_with?("@@")
+              theme.paint(stripped, :info)
+            elsif stripped.start_with?("+")
+              theme.paint(stripped, :added)
+            elsif stripped.start_with?("-")
+              theme.paint(stripped, :removed)
+            else
+              theme.paint(stripped, :dim)
+            end
+          "#{styled}\n"
+        end.join
+      end
+
+      # Single-key follow-up. Never raw #gets: mixing plain gets with Reline
+      # wedges the prompt on Windows (see Confirmations) — tty-prompt's
+      # keypress uses the same raw-mode path as every other UI surface.
+      def offer_actions(shell, theme)
+        prompt = Approvals.build_prompt(shell)
+        key = prompt.keypress(theme.paint("  a: uygula (!apply) · q veya enter: çık ", :dim))
+        apply_all(shell) if key.to_s.strip.downcase == "a"
+      rescue Interrupt
+        Rubik::REPL::InterruptHandler.restore_console_after_interrupt
+      rescue StandardError => e
+        # apply! fails loud on containment breaks and IO errors — the user
+        # pressed "a", so the verdict must reach them, not vanish here.
+        shell.output.puts "\n[Hata] Uygulama başarısız: #{e.message}"
+      end
+
+      def apply_all(shell)
+        applied = shell.buffer_manager.apply!
+        if applied.empty?
+          shell.output.puts "Uygulanacak değişiklik kalmadı."
+        else
+          shell.sync_context_and_ast(applied)
+          shell.output.puts "Uygulandı: #{applied.join(', ')}"
+        end
+      end
+
+      def interactive?(shell)
+        Capability.interactive?(input: shell.input, output: shell.output)
+      end
+    end
+  end
+end

data/lib/rubik/ui/frame.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "io/console"
+
+module Rubik
+  module UI
+    # Minimal rounded frame drawing used by the banner, approval cards and
+    # the input-box prompt. The glyphs come from the active Theme (unicode
+    # rounded or ascii), so the same code degrades gracefully on legacy
+    # consoles.
+    module Frame
+      # Terminal width of the given output (or the controlling console).
+      def self.width(io = nil)
+        w = if io.respond_to?(:winsize)
+              begin
+                io.winsize[1]
+              rescue SystemCallError, IOError
+                nil
+              end
+            end
+        w = w.to_i
+        return w if w.positive?
+
+        console = begin
+          IO.console
+        rescue SystemCallError
+          nil
+        end
+        cols = console&.winsize&.[](1).to_i
+        cols.positive? ? cols : 80
+      end
+
+      # Standalone top border with an optional title segment; shared by
+      # #draw and the input-box prompt (ui.input_box).
+      def self.top_border(theme, width:, title: nil)
+        g = theme.glyphs
+        inner = [width - 4, 8].max
+        title_part = title ? "#{g[:dash]} #{title} " : ""
+        title_pad = [inner + 1 - display_width(title_part), 0].max
+        "#{g[:corner_tl]}#{g[:dash]}#{title_part}#{g[:dash] * title_pad}#{g[:corner_tr]}"
+      end
+
+      # Standalone bottom border matching #top_border.
+      def self.bottom_border(theme, width:)
+        g = theme.glyphs
+        inner = [width - 4, 8].max
+        "#{g[:corner_bl]}#{g[:dash] * (inner + 2)}#{g[:corner_br]}"
+      end
+
+      # Draws a one-cell padded frame around content lines.
+      # Returns the frame as a single string (with trailing newline).
+      def self.draw(lines, theme:, width: 60, title: nil)
+        return "" if lines.empty?
+
+        inner = [width - 4, 8].max
+        content = lines.map { |l| truncate_plain(theme, l, inner) }
+
+        out = +""
+        out << "#{top_border(theme, width: width, title: title)}\n"
+        content.each { |l| out << "#{theme.glyph(:rail)} #{l}#{' ' * [inner - display_width(l), 0].max} #{theme.glyph(:rail)}\n" }
+        out << "#{bottom_border(theme, width: width)}\n"
+        out
+      end
+
+      # Truncates to exactly `max` display cells, reserving room for the
+      # theme's ellipsis glyph ("…" unicode / "..." ascii) so every row
+      # keeps the frame's uniform width.
+      def self.truncate_plain(theme, str, max)
+        ellipsis = theme.glyph(:ellipsis)
+        return str if display_width(str) <= max
+
+        "#{str[0...(max - display_width(ellipsis))]}#{ellipsis}"
+      rescue ArgumentError
+        str[0...max]
+      end
+
+      # East-Asian wide + common emoji blocks that render two columns wide
+      # in terminals; padding must account for them or the right rail
+      # drifts (e.g. the 🎲 banner row).
+      WIDE_RANGES = [
+        [0x1100, 0x115F], [0x2E80, 0xA4CF], [0xAC00, 0xD7A3],
+        [0xF900, 0xFAFF], [0xFE30, 0xFE4F], [0xFF00, 0xFF60],
+        [0xFFE0, 0xFFE6], [0x1F300, 0x1F64F], [0x1F680, 0x1F6FF],
+        [0x1F900, 0x1F9FF], [0x20000, 0x3FFFD]
+      ].freeze
+
+      def self.display_width(str)
+        Capability.strip_ansi(str.to_s).each_char.sum do |chr|
+          ord = chr.ord
+          WIDE_RANGES.any? { |(a, b)| ord.between?(a, b) } ? 2 : 1
+        end
+      end
+    end
+  end
+end

data/lib/rubik/ui/markdown_stream.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "tty-markdown"
+
+module Rubik
+  module UI
+    # Line-oriented live markdown renderer for the streaming token flow.
+    # Completed lines are styled the moment their newline arrives (bold
+    # headings, inline code, fenced code rails); the tail is flushed on
+    # chunk_end. When styling is disabled (non-TTY / ui.markdown: off) every
+    # segment passes through verbatim so piped output stays byte-identical
+    # with the pre-UI streaming behavior.
+    #
+    # Until a step's first visible content arrives, blank lines are
+    # suppressed: the spinner's erased line plus the model's habitual
+    # leading "\n\n" would otherwise paint 2-3 empty rows at every step
+    # boundary. #finish ends one streamed response (Shell calls it on
+    # :chunk_end) and re-arms the suppression for the next step.
+    class MarkdownStream
+      def initialize(theme, enabled: true)
+        @theme = theme
+        @enabled = enabled && theme.color?
+        @pending = +""
+        @in_fence = false
+        @content_started = false
+      end
+
+      # Feeds a streaming delta. Yields ready-to-print segments (including
+      # their trailing newline) to the block as they complete.
+      def push(delta)
+        return if delta.nil? || delta.empty?
+
+        @pending << delta
+        while (idx = @pending.index("\n"))
+          line = @pending.slice!(0..idx)
+          next if suppress_leading_blank?(line)
+
+          yield render_segment(line)
+        end
+      end
+
+      # Flushes the buffered tail at end-of-stream. Yields the final segment
+      # (plus a terminating newline when anything was streamed mid-line) so
+      # the caller never leaves the cursor hanging. Always re-arms leading
+      # blank suppression: one #finish call == one streamed step (:chunk_end).
+      def finish
+        unless @pending.empty?
+          tail = @pending
+          @pending = +""
+          yield "#{render_segment(tail)}\n" unless suppress_leading_blank?(tail)
+        end
+        @content_started = false
+      end
+
+      # Renders a complete markdown document in one shot (batch mode /
+      # command output). Falls back to the raw text when styling is off.
+      def self.render_document(text, theme, enabled: true)
+        return text if text.nil? || text.empty?
+        return text unless enabled && theme.color?
+
+        TTY::Markdown.parse(text, color: :always)
+      end
+
+      private
+
+      # Leading-blank suppression (enabled styling only — piped output keeps
+      # its byte-identical contract). Marks the first visible line and lets
+      # everything after it through untouched.
+      def suppress_leading_blank?(line)
+        return false unless @enabled
+        return false if @content_started
+
+        if line.strip.empty?
+          true
+        else
+          @content_started = true
+          false
+        end
+      end
+
+      def render_segment(segment)
+        return segment unless @enabled
+
+        line = segment.chomp
+        rendered =
+          if line.start_with?("```")
+            @in_fence = !@in_fence
+            @theme.paint(line, :dim)
+          elsif @in_fence
+            "#{@theme.paint("#{@theme.glyph(:rail)} ", :dim)}#{@theme.paint(line, :dim)}"
+          elsif line =~ /\A(#+)\s+(.*)\z/
+            @theme.paint("#{Regexp.last_match(1)} #{Regexp.last_match(2)}", :bold)
+          else
+            style_inline(line)
+          end
+        "#{rendered}#{"\n" if segment.end_with?("\n")}"
+      end
+
+      # Inline styles: **bold**, `code`. Conservative regexes; unmatched
+      # markers stay visible rather than swallowing text.
+      def style_inline(line)
+        out = line.gsub(/\*\*([^*]+)\*\*/) { @theme.paint(Regexp.last_match(1), :bold) }
+        out.gsub(/`([^`]+)`/) { |seg| @theme.paint(seg, :info) }
+      end
+    end
+  end
+end

data/lib/rubik/ui/panel.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+
+module Rubik
+  module UI
+    # Interactive agent/fiber board (`!agents`, the Antigravity /agents
+    # counterpart): lists runtime fibers with state and current activity,
+    # then offers an arrow-key detail view (state history, coeffect
+    # dependencies, orchestrator progress, Omega accumulator depth).
+    # Falls back to a static listing for pipes and tests.
+    module Panel
+      STATE_GLYPHS = {
+        active: "🟢",
+        pending: "⏳",
+        failed: "🔴",
+        disposed: "⚫",
+        unloaded: "⚪"
+      }.freeze
+
+      module_function
+
+      def render(shell, theme)
+        fibers = shell.runtime_manager&.fibers || {}
+        if fibers.empty?
+          shell.output.puts "Kayıtlı fiber/ajan yok."
+          return
+        end
+
+        shell.output.puts "=== Ajan / Fiber Panosu ==="
+        rows = fibers.values.sort_by { |f| STATE_ORDER[f.state] || 99 }
+        rows.each do |fiber|
+          shell.output.puts detail_line(fiber, theme)
+        end
+
+        return unless interactive?(shell)
+
+        choice = select_fiber(shell, rows, theme)
+        show_fiber_detail(shell, choice, theme) if choice
+      end
+
+      def detail_line(fiber, theme)
+        glyph = STATE_GLYPHS[fiber.state] || "❔"
+        activity = current_activity(fiber)
+        name_col = fiber.name.ljust(24)
+        "#{glyph} #{theme.paint(name_col, fiber.state == :active ? :accent : :dim)} #{activity}"
+      end
+
+      def current_activity(fiber)
+        inst = fiber.instance
+        if inst.respond_to?(:step_count)
+          depth = fiber.sub_context ? " · Ω#{fiber.sub_context.disposable_count}" : ""
+          "adım #{inst.step_count}/#{inst.max_steps}#{depth}"
+        elsif fiber.state == :failed
+          "hata: #{fiber.last_error&.message.to_s[0, 50]}"
+        else
+          deps = fiber.inject
+          deps.empty? ? "-" : "coeffects: #{deps.join(', ')}"
+        end
+      end
+
+      def select_fiber(shell, rows, _theme)
+        prompt = Approvals.build_prompt(shell)
+        choices = rows.map { |f| { name: "#{STATE_GLYPHS[f.state]} #{f.name}", value: f } }
+        choices << { name: "← çıkış", value: nil }
+        prompt.select("Detay için fiber seç:") do |menu|
+          choices.each { |c| menu.choice c[:name], c[:value] }
+        end
+      rescue Interrupt
+        Rubik::REPL::InterruptHandler.restore_console_after_interrupt
+        nil
+      rescue StandardError
+        nil
+      end
+
+      def show_fiber_detail(shell, fiber, theme)
+        inst = fiber.instance
+        shell.output.puts
+        shell.output.puts theme.paint("── #{fiber.name} ──", :bold)
+        shell.output.puts "  Durum       : #{STATE_GLYPHS[fiber.state]} #{fiber.state}"
+        shell.output.puts "  Coeffects   : #{fiber.inject.join(', ')}"
+        shell.output.puts "  Ω derinliği : #{fiber.sub_context ? fiber.sub_context.disposable_count : 0}"
+        if inst.respond_to?(:step_count)
+          shell.output.puts "  Adım        : #{inst.step_count}/#{inst.max_steps}"
+          shell.output.puts "  Token       : #{inst.total_tokens.inspect}" if inst.respond_to?(:total_tokens)
+        end
+        shell.output.puts "  Son hata    : #{fiber.last_error&.message}" if fiber.last_error
+        shell.output.puts theme.paint("  (enter ile panoya dön)", :dim)
+      end
+
+      def interactive?(shell)
+        Capability.interactive?(input: shell.input, output: shell.output)
+      end
+
+      STATE_ORDER = { active: 0, pending: 1, failed: 2, disposed: 3, unloaded: 4 }.freeze
+    end
+  end
+end

data/lib/rubik/ui/renderer.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../platform"
+require_relative "../uris"
+require_relative "../repl/step_formatter"
+require_relative "spinner"
+require_relative "capability"
+require_relative "theme"
+
+module Rubik
+  module UI
+    # Display formatter for orchestrator step events implementing the Rubik
+    # agent-flow visual language:
+    #
+    #   ✻ Kavuruyor · 3s (ctrl+c: kes)          <- live spinner (UI::Spinner)
+    #   ⏺ read_file — lib/main.rb               <- action line
+    #     ⎿ 3 lines · 15.2ms                    <- nested result branch
+    #
+    # Responsibilities (Plan 51, Decision D2 — StepFormatter stays the
+    # semantic layer, this class is the presentation decorator):
+    #   * owns the Spinner lifecycle (:thinking starts it, any other event
+    #     stops it before text is printed),
+    #   * maps the 13 orchestrator event types to the glyph tree at
+    #     normal/verbose levels, consuming the legacy formatter's public
+    #     semantic helpers (thinking_parts, primary_arg_value,
+    #     summarize_result, thought_first_line) instead of re-parsing events,
+    #   * delegates raw [DEBUG:...] lines verbatim at debug level and
+    #     re-anchors stable event bodies (warnings, retries, finish) with
+    #     two leading spaces,
+    #   * paints through the Theme so disabled color yields plain text with
+    #     identical glyphs (one visual language, deterministic pipes).
+    class Renderer
+      LEVEL_QUIET = Rubik::REPL::StepFormatter::LEVEL_QUIET
+
+      attr_reader :spinner, :theme
+
+      def initialize(output:, config: nil, verbosity: nil, max_steps: nil, theme: nil)
+        @config = config
+        @max_steps = max_steps
+        @output = output
+        @theme = theme || Theme.for(output, config)
+        @legacy = Rubik::REPL::StepFormatter.new(config: config, verbosity: verbosity, max_steps: max_steps)
+        @spinner = Spinner.new(output, @theme, config: config)
+        @spinner_capable = Capability.spinner?(output, config) && level > LEVEL_QUIET
+      end
+
+      def level
+        @legacy.level
+      end
+
+      # Renders one orchestrator event to a printable String (or nil to stay
+      # silent). Must be called for EVERY event so the spinner is stopped
+      # before any other output is printed.
+      def render(step_info)
+        return nil unless step_info.is_a?(Hash)
+
+        type = step_info[:type]&.to_sym
+
+        # Teslimat süslemeden önce gelir: :user_output debug dahil her
+        # seviyede doğrudan işlenir — debug delegasyonu onu StepFormatter'a
+        # (kolu yok → nil) götürür ve stub yalan olurdu.
+        return render_user_output(step_info) if type == :user_output
+
+        # Raw debug lines come verbatim from the legacy formatter.
+        return @legacy.format(step_info) if level >= Rubik::REPL::StepFormatter::LEVEL_DEBUG
+
+        case type
+        when :thinking then render_thinking(step_info)
+        when :tool_call then render_tool_call(step_info)
+        when :tool_result then render_tool_result(step_info)
+        when :user_output then render_user_output(step_info)
+        when :llm_thought then render_llm_thought(step_info)
+        when :chunk, :chunk_end
+          @spinner.stop
+          nil
+        else
+          restyle_legacy(step_info)
+        end
+      end
+
+      private
+
+      def render_thinking(step_info)
+        return nil if level <= LEVEL_QUIET
+
+        if @spinner_capable
+          @spinner.start(step: step_info[:step], max_steps: step_info[:max_steps])
+          return nil
+        end
+
+        parts = @legacy.thinking_parts(step_info)
+        target_part = parts[:target].empty? ? "" : " (#{parts[:target]})"
+        "#{@theme.glyph(:clock)} #{@theme.spinner_verbs.first} [#{parts[:step]}/#{parts[:max]}]#{target_part}"
+      end
+
+      def render_tool_call(step_info)
+        @spinner.stop
+        return nil if level <= LEVEL_QUIET
+
+        tool = step_info[:tool]
+        args = step_info[:args] || {}
+        header = @theme.paint("#{@theme.glyph(:action)} #{tool}", :accent)
+
+        if level >= Rubik::REPL::StepFormatter::LEVEL_VERBOSE
+          "#{header} #{@theme.paint(Rubik::Platform.safe_json_generate(args), :dim)}"
+        else
+          summary = pretty_storage_arg(@legacy.primary_arg_value(args).to_s)
+          summary.empty? ? header : "#{header} #{theme_dim_dash(summary)}"
+        end
+      end
+
+      # Depo varlıklarını kullanıcıya 'göster' dendiğinde ajan uzun
+      # rubik://storage URI'leri kullanır; eylem satırında önek düşer,
+      # içerik karması 8 hexe kısaltılır (storage-show-surface planı C).
+      #   rubik://storage/js-tangram/review/review.1.b54cddc277e87d25
+      #   → js-tangram/review/review.1.b54cddc2…
+      def pretty_storage_arg(value)
+        rel = Rubik::Uris.storage_relative(value)
+        return value unless rel
+
+        rel.sub(/\.json\z/i, "").sub(/([0-9a-f]{8})[0-9a-f]{8}\z/i, "\\1…")
+      end
+
+      # :user_output (show_file sözleşmesi): tam içerik kullanıcıya aynen
+      # akar — soluklaştırılmaz, okunabilirlik önce gelir; yalnız başlık
+      # satırı dim boyanır. Model bu içeriği görmedi (stub aldı). Bu event
+      # süsleme değil TESLİMAT'tır: quiet dahil her seviyede basılır
+      # (sessiz düşüş, modelin "rendered to terminal" stub'ını yalan yapar).
+      def render_user_output(step_info)
+        @spinner.stop
+
+        header = @theme.paint("#{@theme.glyph(:branch)} #{step_info[:label]}", :dim)
+        "#{header}\n#{step_info[:content]}\n"
+      end
+
+      def render_tool_result(step_info)
+        @spinner.stop
+        return nil if level <= LEVEL_QUIET
+
+        status = (step_info[:status] || :ok).to_sym
+        duration = step_info[:duration_ms] || 0.0
+        output = step_info[:output].to_s
+        branch = "#{@theme.glyph(:branch)} "
+
+        if status != :ok
+          err = step_info[:error]
+          err = output.lines.first.to_s.strip if err.nil? || err.to_s.empty?
+          err = "Command failed" if err.to_s.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
+            "#{branch}#{@theme.paint("#{@theme.glyph(:warn)} #{msg}", :warn)}"
+          else
+            "#{branch}#{@theme.paint("#{@theme.glyph(:err)} #{err} (#{duration}ms)", :error)}"
+          end
+        elsif level >= Rubik::REPL::StepFormatter::LEVEL_VERBOSE
+          lines_size = step_info[:line_count] || output.lines.size
+          byte_size = step_info[:byte_size] || output.bytesize
+          header = "#{branch}#{lines_size} lines (#{byte_size} B, #{duration}ms)"
+          return @theme.paint(header, :dim) if output.empty?
+
+          preview = output.lines.first(5).map { |l| "    #{l.chomp}" }.join("\n")
+          "#{@theme.paint(header, :dim)}\n#{@theme.paint("    #{@theme.glyph(:preview)} Preview:", :dim)}\n#{@theme.paint(preview, :dim)}"
+        else
+          summary = @legacy.summarize_result(output, step_info)
+          "#{branch}#{@theme.paint("#{summary} · #{duration}ms", :dim)}"
+        end
+      end
+
+      def render_llm_thought(step_info)
+        @spinner.stop
+        return nil if level < Rubik::REPL::StepFormatter::LEVEL_VERBOSE
+
+        first_line = @legacy.thought_first_line(step_info[:content])
+        return nil if first_line.nil? || first_line.empty?
+
+        "  #{@theme.paint("#{@theme.glyph(:thought)} #{first_line}", :thought)}"
+      end
+
+      # Events whose message bodies stay stable (warnings, retries, finish,
+      # auto-apply, compaction): keep the legacy text, re-anchor it to the
+      # glyph tree with two leading spaces.
+      def restyle_legacy(step_info)
+        @spinner.stop
+        legacy_line = @legacy.format(step_info)
+        return nil if legacy_line.nil? || legacy_line.empty?
+
+        styled = case step_info[:type]&.to_sym
+                 when :step_warning, :emergency_compact, :llm_retry
+                   @theme.paint(legacy_line.strip, :warn)
+                 when :auto_apply, :finish
+                   @theme.paint(legacy_line.strip, :success)
+                 else
+                   legacy_line.strip
+                 end
+        "  #{styled}"
+      end
+
+      def theme_dim_dash(text)
+        @theme.paint("— #{text}", :dim)
+      end
+    end
+  end
+end