rubik 0.1.0

data/lib/rubik/ui/spinner.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "tty-spinner"
+
+module Rubik
+  module UI
+    # Live status spinner shown while the orchestrator queries the LLM:
+    # cycling Turkish verbs (Claude-Code-style) plus elapsed seconds, drawn
+    # on a single terminal line. Owns a background thread whose lifecycle is
+    # tied to #stop/#kill; the Runtime RenderService registers `kill` as a
+    # context inverse so disposed shells never leak spinner threads.
+    class Spinner
+      TICK_SECONDS = 0.12
+      ELAPSED_STEP = 1.0
+
+      def initialize(io, theme, config: nil)
+        @io = io
+        @theme = theme
+        @config = config
+        @thread = nil
+        @mutex = Mutex.new
+        @spinner = nil
+        @started_at = nil
+        @last_elapsed_shown = -1
+      end
+
+      def enabled?
+        @config ? @config.fetch("ui.spinner", true) != false : true
+      end
+
+      def spinning?
+        @thread&.alive? == true
+      end
+
+      # Starts spinning with the next verb from the theme's rotation.
+      # No-op when the surface is disabled (non-TTY, tests, quiet terminals).
+      def start(step: nil, max_steps: nil)
+        return unless enabled?
+        return if spinning?
+
+        verb = next_verb
+        step_part = step && max_steps ? " [#{step}/#{max_steps}]" : ""
+        @started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        @last_elapsed_shown = -1
+
+        @mutex.synchronize do
+          # The message template carries :spinner and :msg tokens so #update
+          # actually substitutes the verb/step/elapsed text; `clear: true`
+          # makes tty-spinner erase its own line on stop (no stray frame).
+          @spinner = TTY::Spinner.new(":spinner :msg", output: @io, format: :spin,
+                                                       hide_cursor: true, clear: true)
+          @spinner.update(msg: "#{@theme.paint(verb, :accent)}#{step_part}")
+          @spinner.spin
+        end
+
+        @thread = Thread.new do
+          loop do
+            sleep TICK_SECONDS
+            break unless spinning?
+
+            elapsed = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - @started_at)
+            @mutex.synchronize do
+              next unless @spinner && !@spinner.done?
+
+              if elapsed - @last_elapsed_shown >= ELAPSED_STEP
+                @last_elapsed_shown = elapsed
+                @spinner.update(msg: current_message(verb, step_part, elapsed))
+              end
+              @spinner.spin
+            rescue StandardError => e
+              # A dead tick thread must not take the REPL down, but the
+              # failure is never silent (AGENTS.md §5): report, then exit.
+              warn "[rubik] spinner tick failed: #{e.class}: #{e.message}"
+              Thread.exit
+            end
+          end
+        end
+      end
+
+      # Stops the spinner and clears its line so the caller can print freely.
+      # `final:` optionally leaves a completion note on the cleared line.
+      def stop(final: nil)
+        thread = @thread
+        @thread = nil
+        thread&.kill
+        thread&.join(0.3)
+
+        @mutex.synchronize do
+          if @spinner
+            begin
+              @spinner.stop
+              @io.print(final) unless final.nil?
+              @io.flush if @io.respond_to?(:flush)
+            rescue StandardError => e
+              # Cleanup must never mask the caller's in-flight exception
+              # (AGENTS.md §5): report the IO failure and still nil @spinner
+              # so repeated stops stay idempotent.
+              warn "[rubik] spinner cleanup failed: #{e.class}: #{e.message}"
+            ensure
+              @spinner = nil
+            end
+          end
+        end
+      end
+      alias kill stop
+      alias dispose stop
+
+      def current_message(verb, step_part, elapsed)
+        seconds = elapsed.to_i
+        suffix = seconds.positive? ? " · #{seconds}s" : ""
+        "#{@theme.paint(verb, :accent)}#{step_part}#{suffix} (ctrl+c: kes)"
+      end
+
+      def next_verb
+        @verb_index = ((@verb_index || -1) + 1) % @theme.spinner_verbs.size
+        @theme.spinner_verbs[@verb_index]
+      end
+    end
+  end
+end

data/lib/rubik/ui/statusline.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require_relative "../prompt/token_estimator"
+
+module Rubik
+  module UI
+    # Compact context strip printed above the prompt line before every read:
+    # active model, estimated context-window usage, dirty buffer count and
+    # sandbox state. Customizable via `ui.statusline_template` placeholders:
+    #   {project} {branch} {model} {ctx} {dirty} {sandbox} {verbosity}
+    module Statusline
+      module_function
+
+      def render(shell, theme)
+        return nil unless shell.config.fetch("ui.statusline", true)
+
+        template = shell.config.fetch("ui.statusline_template", default_template)
+        # `!config set ui.statusline_template "{a} {b}"` can arrive parsed as
+        # a YAML flow-mapping Hash; coerce any non-String back to the default.
+        template = default_template unless template.is_a?(String)
+
+        routed = current_route(shell)
+        units_str = units_segment(shell)
+        values = {
+          "project" => File.basename(shell.buffer_manager&.root_dir || Dir.pwd),
+          "branch" => shell.detect_git_branch || "-",
+          "model" => model_label(routed),
+          "ctx" => context_usage(shell, routed),
+          "dirty" => dirty_segment(shell, theme),
+          "sandbox" => sandbox_segment(shell),
+          "verbosity" => shell.config.fetch("ui.verbosity", "normal"),
+          "units" => units_str
+        }
+
+        line = template.gsub(/\{(\w+)\}/) { values.fetch(::Regexp.last_match(1)) { "{#{::Regexp.last_match(1)}}" } }
+        line += " · [#{units_str}]" if !template.include?("{units}") && active_units_count(shell).positive?
+        theme.paint(line, :dim)
+      end
+
+      def default_template
+        "{model} · ctx {ctx} · {dirty} · sandbox {sandbox}"
+      end
+
+      def current_route(shell)
+        shell.router.route(task_type: :default)
+      rescue StandardError => e
+        # Edge-triggered warn: render runs before every prompt read, so an
+        # unguarded warn would spam one line per redraw on a broken router.
+        unless @route_failure_warned
+          @route_failure_warned = true
+          Rubik::Log.warn(:ui, "statusline route lookup failed (#{e.class}: #{e.message}); model shows '-'")
+        end
+        nil
+      end
+
+      # "provider/model" label shared with the banner.
+      def model_label(routed)
+        return "-" unless routed
+
+        provider = routed[:spec].is_a?(Hash) ? (routed[:spec]["provider"] || routed[:spec][:provider]) : nil
+        "#{provider || 'unknown'}/#{routed[:model]}"
+      end
+
+      # Estimated share of the context window consumed by the in-memory
+      # dialogue history, e.g. "34%" (or "-" when the limit is unknown).
+      def context_usage(shell, routed)
+        limit = routed&.fetch(:context_limit, nil).to_i
+        return "-" unless limit.positive?
+
+        tokens = Rubik::Prompt::TokenEstimator.estimate_history(shell.conversation_history || [])
+        pct = ((tokens.to_f / limit) * 100).round
+        pct = 100 if pct > 100
+        "#{pct}%"
+      end
+
+      def dirty_segment(shell, theme)
+        count = shell.buffer_manager&.dirty? ? (shell.buffer_manager.dirty_files&.size || 0) : 0
+        count.zero? ? "temiz" : "#{count} #{theme.glyph(:dirty)}"
+      end
+
+      def sandbox_segment(shell)
+        if shell.config.fetch("sandbox.enabled", false)
+          net_str = shell.config.fetch("sandbox.allow_network", false) ? "ağ-açık" : "izole"
+          "#{shell.sandbox_runner&.driver&.name || 'sandbox'}:#{net_str}"
+        else
+          "kapalı"
+        end
+      end
+
+      def active_units_count(shell)
+        running, paused = active_units_breakdown(shell)
+        running + paused
+      end
+
+      def active_units_breakdown(shell)
+        if shell.respond_to?(:init) && shell.init
+          # Kernel branch (translated unit states): Unit::PAUSED_STATES is
+          # the single spelling. :active deliberately covers :waiting_input
+          # here — the fallback branch's executing? below does not; the
+          # planes disagree on that one state, on purpose.
+          running = shell.init.units_by_state(:active).size
+          paused = shell.init.units_by_state(*Rubik::Kernel::Unit::PAUSED_STATES).size
+          [running, paused]
+        elsif shell.respond_to?(:subagent_supervisor) && shell.subagent_supervisor
+          insts = shell.subagent_supervisor.instances.values
+          running = insts.count(&:executing?)
+          paused = insts.count(&:parked?)
+          [running, paused]
+        else
+          [0, 0]
+        end
+      rescue StandardError => e
+        unless @units_failure_warned
+          @units_failure_warned = true
+          Rubik::Log.warn(:ui, "statusline unit-state lookup failed (#{e.class}: #{e.message}); showing 0 units")
+        end
+        [0, 0]
+      end
+
+      def units_segment(shell)
+        running, paused = active_units_breakdown(shell)
+        if running.positive? && paused.positive?
+          "⚙️ #{running} running, ⏸️ #{paused} paused"
+        elsif running.positive?
+          "⚙️ #{running} units running"
+        elsif paused.positive?
+          "⏸️ #{paused} units paused"
+        else
+          "0 units"
+        end
+      end
+    end
+  end
+end

data/lib/rubik/ui/theme.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "pastel"
+require_relative "../platform"
+require_relative "capability"
+
+module Rubik
+  module UI
+    # Single source of truth for the Rubik display language: palette, glyph
+    # sets (unicode / ascii fallback) and spinner verbs. All visual components
+    # decorate through a Theme so `ui.color: never` / NO_COLOR / non-TTY pipes
+    # collapse every surface back to plain deterministic text.
+    class Theme
+      # Color-blind safe default palette: positive states (success/added)
+      # live on the blue axis (:cyan) and negative states (error/removed) on
+      # :red, so no distinction ever rests on the red-vs-green axis (the
+      # classic deuteranopia/protanopia confusion). Structural/meta text uses
+      # :blue to keep :cyan unambiguous as the "positive" hue. Named ANSI
+      # codes render differently per terminal theme, but the axis separation
+      # holds in all of them.
+      STYLES = {
+        accent: [:bright_red],
+        success: [:cyan],
+        error: [:red, :bold],
+        warn: [:yellow],
+        info: [:blue],
+        dim: [:bright_black],
+        thought: [:bright_black, :italic],
+        bold: [:bold],
+        added: [:cyan],
+        removed: [:red]
+      }.freeze
+
+      GLYPHS = {
+        unicode: {
+          action: "⏺", branch: "⎿", spinner: "✻", thought: "💭",
+          ok: "✔", err: "✖", warn: "⚠", retry: "↻", finish: "🏁",
+          bolt: "⚡", clock: "⏳", dirty: "✎", rail: "│", dash: "─",
+          corner_tl: "╭", corner_tr: "╮", corner_bl: "╰", corner_br: "╯",
+          cursor: "›", preview: "↳", ellipsis: "…"
+        }.freeze,
+        ascii: {
+          action: "*", branch: "`", spinner: "*", thought: "o",
+          ok: "+", err: "x", warn: "!", retry: "r", finish: "#",
+          bolt: "!", clock: "~", dirty: "*", rail: "|", dash: "-",
+          corner_tl: "+", corner_tr: "+", corner_bl: "+", corner_br: "+",
+          cursor: ">", preview: "->", ellipsis: "..."
+        }.freeze
+      }.freeze
+
+      DEFAULT_SPINNER_VERBS = [
+        "Düşünüyor", "Kavuruyor", "Karıştırıyor", "Damıtıyor", "Biçimlendiriyor", "Harmanlıyor", "Tarıyor", "Planlıyor", "Doğruluyor", "Tamamlıyor"
+      ].freeze
+
+      attr_reader :pastel, :glyphs, :spinner_verbs
+
+      def initialize(enabled: true, glyph_set: :unicode, spinner_verbs: DEFAULT_SPINNER_VERBS)
+        @pastel = Pastel.new(enabled: enabled)
+        set_name = GLYPHS.key?(glyph_set.to_sym) ? glyph_set.to_sym : :unicode
+        @glyphs = GLYPHS[set_name]
+        verbs = Array(spinner_verbs)
+        @spinner_verbs = verbs.empty? ? DEFAULT_SPINNER_VERBS : verbs
+      end
+
+      # Builds the theme the Shell subsystem should use for a given output IO
+      # and config. Called on Shell init and ui.* refresh — not on the
+      # per-token hot path. Unicode glyphs are downgraded to the ascii set
+      # when the output's external encoding cannot encode them (redirected
+      # legacy-codepage consoles on Windows), preventing conversion errors.
+      def self.for(io, config = nil)
+        enabled = Capability.color?(io, config)
+        glyph_set = (config&.fetch("ui.glyphs", "unicode") || "unicode").to_sym
+        glyph_set = :ascii if glyph_set == :unicode && !unicode_supported?(io)
+        verbs = config&.fetch("ui.spinner_verbs", nil)
+        new(enabled: enabled, glyph_set: glyph_set, spinner_verbs: verbs)
+      end
+
+      def self.unicode_supported?(io)
+        return true unless io.respond_to?(:external_encoding)
+
+        enc = io.external_encoding
+        return true if enc.nil? # default external (UTF-8 on modern Rubies)
+
+        "⏺".encode(enc)
+        true
+      rescue Encoding::UndefinedConversionError, Encoding::ConverterNotFoundError
+        false
+      end
+
+      def color?
+        pastel.enabled?
+      end
+
+      # Applies a named style. Returns plain text verbatim when color is off.
+      def paint(text, style_name)
+        return text.to_s unless color?
+
+        style = STYLES[style_name]
+        unless style
+          # Unknown styles used to fall through silently (the banner's :yellow
+          # hint rendered unstyled for months); surface that in debug mode
+          # instead of swallowing it (warned once per style).
+          if ENV["RUBIK_DEBUG"]
+            @warned_styles ||= Set.new
+            Rubik::Platform.debug_warn("UI::Theme#paint: unknown style #{style_name.inspect}, rendering plain") if @warned_styles.add?(style_name)
+          end
+          return text.to_s
+        end
+
+        pastel.decorate(text.to_s, *style)
+      end
+
+      def glyph(name)
+        glyphs.fetch(name, "")
+      end
+    end
+  end
+end

data/lib/rubik/ui.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "ui/capability"
+require_relative "ui/theme"
+require_relative "ui/frame"
+require_relative "ui/banner"
+require_relative "ui/statusline"
+require_relative "ui/spinner"
+require_relative "ui/renderer"
+require_relative "ui/markdown_stream"
+require_relative "ui/approvals"
+require_relative "ui/panel"
+require_relative "ui/diff_viewer"
+
+require_relative "runtime/service_registration"
+
+module Rubik
+  # Terminal display layer (Plan 51): theme, capability detection, agent-flow
+  # renderer, live spinner, markdown streaming and interactive approval /
+  # panel surfaces. Registered into the Runtime as a coeffect service so
+  # synthesized tools and plugins can resolve `ui` and `theme` through the
+  # context, and so spinner threads are disposed with their context (LIFO
+  # inverse), never leaked.
+  module UI
+    module RenderService
+      module_function
+
+      # Wires the display layer into the runtime context.
+      # Returns the Renderer; also provides `ui` (renderer) and `theme`.
+      # Idempotent on re-registration (`Shell#refresh_ui!`): service values
+      # are swapped, the delete-inverses are not stacked, and the single
+      # spinner-kill inverse resolves the CURRENT renderer at dispose time,
+      # so repeated refreshes never grow the Omega accumulator.
+      # `output:` lets callers bind to the real terminal when the shell's
+      # current @output is a transient capture TeeIO.
+      def register(context_or_manager, shell:, output: nil)
+        Rubik::Runtime::ServiceRegistration.call(context_or_manager) do |ctx|
+          next nil unless ctx
+
+          out = output || shell.output
+          theme = Theme.for(out, shell.config)
+          renderer = Renderer.new(config: shell.config, output: out, theme: theme)
+
+          existing_renderer = ctx.get("ui")
+          existing_renderer.spinner&.kill if existing_renderer.respond_to?(:spinner) && existing_renderer.spinner
+
+          first_registration = !ctx.has?("ui")
+          ctx.provide("ui", renderer)
+          ctx.provide("theme", theme)
+          ctx.on_dispose { (ctx.get("ui") || renderer)&.spinner&.kill } if first_registration
+
+          renderer
+        end
+      end
+    end
+  end
+end

data/lib/rubik/uris.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Rubik
+  # rubik:// sanal URI gramerinin TEK evi (uri-resolver-seam planı
+  # 2026-10-01). Şemalar üç alanı kapsar (storage = FS-DB, subagent =
+  # orchestrator yapısı, goal = canlı orchestrator anlık görüntüsü) —
+  # dolayısıyla gramer storage'a ait değildir; bağımlılıksız yaprak olarak
+  # burada yaşar (coeffects.rb/platform.rb öncülü). Desenler, çözümleyiciler
+  # ve URI kurucuları yalnızca bu modüldedir; bekçi testi
+  # (test_architectural_boundaries.rb) lib/ içinde başka rubik:// regexi
+  # yasaklar. Buradaki desenler büyük/küçük harf duyarsızdır (\i) — mevcut
+  # çağrı yüzeyleri hiçbir değişiklik olmadan aynen kalır.
+  module Uris
+    SCHEME = "rubik"
+    STORAGE = "storage"
+    GOAL = "goal"
+    SUBAGENT = "subagent"
+
+    # Desenler — lib/ içinde izin verilen TEK rubik:// regexleri.
+    # Şema segmenti: [a-z][a-z0-9_-]* (çözümleme anahtarları küçük harfe
+    # iner; scheme_of). Önek ya da URI sonunda olmalı; yarıda kesilmez.
+    SCHEME_PREFIX = %r{\Arubik://([a-z][a-z0-9_-]*)}i
+    STORAGE_PREFIX = %r{\Arubik://storage(?:/|\z)}i
+    STORAGE_RELATIVE = %r{\Arubik://storage/(.*)\z}i
+    GOAL_STATE = %r{\Arubik://goal(?:/state)?(?:\.xml)?\z}i
+    # Yapılandırılmış Σ okuma yüzeyi (goal-ledger planı A): /state regexi
+    # /ledger'ı EŞLEMEZ — iki ayrı gramer, tek adapter içinde iç dispatch.
+    GOAL_LEDGER = %r{\Arubik://goal/ledger(?:\.xml)?\z}i
+    SUBAGENT_TRANSCRIPT = %r{\Arubik://subagent/([^/]+)/transcript(?:\.jsonl)?(?:#.*)?\z}i
+
+    # TranscriptIndexer ref sözleşimi: "subagent-<storage-id>".
+    TRANSCRIPT_REF_PREFIX = "subagent-"
+
+    module_function
+
+    # -> "storage"|"goal"|"subagent"|... ya da nil (rubik:// değil).
+    # to_s: nil/sembol girdiler dürüst nil düşer (NoMethodError yok).
+    def scheme_of(uri)
+      m = uri.to_s.match(SCHEME_PREFIX)
+      m[1].downcase if m
+    end
+
+    # Kanonik soyma (uri_reader.rb'nin tarihsel biçimi): önek + ilk eğik
+    # çizgi düşer. -> "uriproj/goal/1" | nil. Çıplak kök ("rubik://storage")
+    # boş dize döndürür — UriReader bunu malformed olarak raporlar.
+    def storage_path(uri)
+      uri.sub(STORAGE_PREFIX, "") if STORAGE_PREFIX.match?(uri)
+    end
+
+    # Kozmetik görüntüleme soyması (show_file stub'ı, ui/renderer
+    # kısaltması): zorunlu eğik çizgi, gerisi aynen. -> "proj/type/id" |
+    # nil. Kanonik storage_path'ten FARKLIDIR (ör. "rubik://storage" çıplak
+    # kökü soymaz) — yalnızca sunumda kullanılır, ayrıştırma için değil.
+    def storage_relative(uri)
+      m = uri.match(STORAGE_RELATIVE)
+      m[1] if m
+    end
+
+    def storage_entity(project:, type:, id:)
+      "#{SCHEME}://#{STORAGE}/#{project}/#{type}/#{id}"
+    end
+
+    def storage_project(project:)
+      "#{SCHEME}://#{STORAGE}/#{project}"
+    end
+
+    def storage_ref(project:, ref:)
+      "#{SCHEME}://#{STORAGE}/#{project}/refs/#{ref}"
+    end
+
+    def storage_listing(project:, type:)
+      "#{SCHEME}://#{STORAGE}/#{project}/#{type}"
+    end
+
+    def storage_index
+      "#{SCHEME}://#{STORAGE}/index"
+    end
+
+    def goal_state
+      "#{SCHEME}://#{GOAL}/state"
+    end
+
+    def goal_ledger
+      "#{SCHEME}://#{GOAL}/ledger"
+    end
+
+    def subagent_transcript(storage_id)
+      "#{SCHEME}://#{SUBAGENT}/#{storage_id}/transcript"
+    end
+
+    # TranscriptIndexer ref sözleşimi: "subagent-<storage-id>". storage-id
+    # kendisi zaten "subagent-" önekli doğar (ör. "subagent-1-12456-...") —
+    # öneki körlemesine eklemek çift önekli, çözümlenemez alias üretiyordu
+    # (js-tangram olay raporu 2026-10-04, olay #4). Önekli girdi aynen
+    # kullanılır.
+    def transcript_ref(storage_id)
+      id = storage_id.to_s
+      id.start_with?(TRANSCRIPT_REF_PREFIX) ? id : "#{TRANSCRIPT_REF_PREFIX}#{id}"
+    end
+  end
+end

data/lib/rubik/version.rb

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

data/lib/rubik.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "rubik/version"
+require_relative "rubik/log"
+require_relative "rubik/platform"
+require_relative "rubik/concurrency"
+require_relative "rubik/uris"
+require_relative "rubik/config"
+require_relative "rubik/event_bus"
+require_relative "rubik/repl"
+require_relative "rubik/repl/terminal_guard"
+require_relative "rubik/ui"
+require_relative "rubik/buffer"
+require_relative "rubik/session"
+require_relative "rubik/context"
+require_relative "rubik/storage"
+require_relative "rubik/ast"
+require_relative "rubik/llm"
+require_relative "rubik/adapter"
+require_relative "rubik/diagnostics"
+require_relative "rubik/tools"
+require_relative "rubik/orchestrator"
+require_relative "rubik/repair"
+require_relative "rubik/security"
+require_relative "rubik/sandbox"
+require_relative "rubik/plugin"
+require_relative "rubik/benchmark"
+require_relative "rubik/lsp"
+require_relative "rubik/mcp"
+require_relative "rubik/runtime"
+require_relative "rubik/skills"
+require_relative "rubik/prompt"
+require_relative "rubik/kernel/record"
+require_relative "rubik/kernel/dmesg"
+require_relative "rubik/kernel/dispatcher"
+require_relative "rubik/kernel/unit"
+require_relative "rubik/kernel/init"
+
+module Rubik
+  class Error < StandardError; end
+
+  class << self
+    attr_accessor :current_shell, :runtime_manager
+
+    # Deprecated read bridge (review Öneri 4 sunset): resolves the runtime
+    # manager from the ambient root. New code must go through the context:
+    # the 'shell' coeffect (Rubik::Coeffects::SHELL) via ctx.require or
+    # Manager#context. Warns once per process.
+    def runtime
+      warn_ambient_read_once
+      runtime_manager || current_shell&.runtime_manager
+    end
+
+    private
+
+    def warn_ambient_read_once
+      return if defined?(@ambient_warned) && @ambient_warned
+
+      @ambient_warned = true
+      warn "[DEPRECATION] Rubik.runtime is deprecated (sunset). Inject the " \
+           "'shell' coeffect (Rubik::Coeffects::SHELL) or read the manager " \
+           "from the owning Shell instead."
+    end
+  end
+end