openclacky 1.3.3 → 1.3.5

data/lib/clacky/null_ui_controller.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "ui_interface"
+
+module Clacky
+  # A UI controller that swallows every event. Used for detached/background
+  # subagents whose intermediate output must never reach a real UI stream
+  # (e.g. the WebUI chat transcript). All UIInterface methods are inherited
+  # as no-ops, so nothing this agent emits is broadcast anywhere.
+  class NullUIController
+    include Clacky::UIInterface
+  end
+end

data/lib/clacky/plain_ui_controller.rb

@@ -117,7 +117,7 @@ module Clacky
       puts_line("[warn] #{message}")
     end
 
-    def show_error(message, code: nil, top_up_url: nil)
+    def show_error(message, code: nil, top_up_url: nil, raw_message: nil)
       puts_line("[error] #{message}")
     end
 

data/lib/clacky/providers.rb

@@ -88,6 +88,30 @@ module Clacky
           "or-tts-gemini-2-5-pro"   => "Gemini 2.5 Pro TTS"
         },
         "default_audio_model" => "or-tts-gemini-2-5-flash",
+        # Speech-to-text models served by the openclacky gateway, which
+        # routes them to Vertex AI Gemini (generateContent with inline
+        # audio parts). The gateway returns transcription text.
+        "stt_models" => [
+          "or-stt-gemini-3-5-flash",
+          "or-stt-gemini-1-5-pro"
+        ],
+        "stt_model_aliases" => {
+          "or-stt-gemini-3-5-flash" => "Gemini 3.5 Flash STT",
+          "or-stt-gemini-1-5-pro"   => "Gemini 1.5 Pro STT"
+        },
+        "default_stt_model" => "or-stt-gemini-3-5-flash",
+        # Video understanding models served by the openclacky gateway, which
+        # routes video frames to Gemini (generateContent with inline image
+        # parts). The gateway returns analysis text.
+        "video_understanding_models" => [
+          "or-gemini-3-5-flash",
+          "or-gemini-3-1-pro"
+        ],
+        "video_understanding_model_aliases" => {
+          "or-gemini-3-5-flash" => "Gemini 3.5 Flash",
+          "or-gemini-3-1-pro"   => "Gemini 3.1 Pro"
+        },
+        "default_video_understanding_model" => "or-gemini-3-5-flash",
         # Default OCR sidecar — used when the primary model is text-only.
         # Candidates are derived from the provider's vision-capable models;
         # this just picks the cheap+fast default to surface in "auto" mode.
@@ -418,7 +442,7 @@ module Clacky
 
     }.freeze
 
-    MEDIA_KINDS = %w[image video audio].freeze
+    MEDIA_KINDS = %w[image video audio stt video_understanding].freeze
 
     class << self
       # Check if a provider preset exists
@@ -549,11 +573,33 @@ module Clacky
         preset&.dig("audio_model_aliases") || {}
       end
 
+      def stt_models(provider_id)
+        preset = PRESETS[provider_id]
+        preset&.dig("stt_models") || []
+      end
+
+      def stt_model_aliases(provider_id)
+        preset = PRESETS[provider_id]
+        preset&.dig("stt_model_aliases") || {}
+      end
+
+      def video_understanding_models(provider_id)
+        preset = PRESETS[provider_id]
+        preset&.dig("video_understanding_models") || []
+      end
+
+      def video_understanding_model_aliases(provider_id)
+        preset = PRESETS[provider_id]
+        preset&.dig("video_understanding_model_aliases") || {}
+      end
+
       def media_model_aliases(provider_id, kind)
         case kind.to_s
         when "image" then image_model_aliases(provider_id)
         when "video" then video_model_aliases(provider_id)
         when "audio" then audio_model_aliases(provider_id)
+        when "stt"   then stt_model_aliases(provider_id)
+        when "video_understanding" then video_understanding_model_aliases(provider_id)
         else {}
         end
       end
@@ -599,13 +645,15 @@ module Clacky
 
       # Unified entry for media model lookup by kind.
       # @param provider_id [String]
-      # @param kind [String] one of "image" / "video" / "audio"
+      # @param kind [String] one of "image" / "video" / "audio" / "stt"
       # @return [Array<String>]
       def media_models(provider_id, kind)
         case kind.to_s
         when "image" then image_models(provider_id)
         when "video" then video_models(provider_id)
         when "audio" then audio_models(provider_id)
+        when "stt"   then stt_models(provider_id)
+        when "video_understanding" then video_understanding_models(provider_id)
         else []
         end
       end

data/lib/clacky/rich_ui/components/base_component.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "ruby_rich"
+
+module Clacky
+  module RichUI
+    module Components
+      # BaseComponent provides shared rendering primitives for RichUI components.
+      # Used by sidebar panels and dialogs to eliminate duplicated ANSI-color helpers.
+      module BaseComponent
+        # Render muted (dim) text commonly used for secondary info
+        def muted(text)
+          "#{RubyRich::AnsiCode.color(:black, true)}#{text}#{RubyRich::AnsiCode.reset}"
+        end
+
+        # Render colored text with a named color
+        def colored(text, color)
+          "#{RubyRich::AnsiCode.color(color, true)}#{text}#{RubyRich::AnsiCode.reset}"
+        end
+
+        # Status marker symbol for todo / activity items
+        def status_marker(status)
+          case status
+          when :done, :completed
+            colored("✓", :green)
+          when :running, :in_progress, :active
+            colored("●", :blue)
+          when :failed, :error
+            colored("!", :red)
+          else
+            muted("○")
+          end
+        end
+
+        # Truncate text to a maximum length, appending "…" when cut
+        def truncate(text, limit = 40)
+          return "" if text.nil? || text.empty?
+
+          text.length > limit ? "#{text[0...limit]}…" : text
+        end
+
+        # Theme accessor for future theme switching.
+        # Currently defaults to agent_dark; can be overridden per-component.
+        def theme
+          @theme ||= RubyRich::Theme.agent_dark
+        end
+      end
+    end
+  end
+end

data/lib/clacky/rich_ui/components/dialogs/approval_dialog.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "ruby_rich"
+require_relative "../base_component"
+
+module Clacky
+    module RichUI
+      class ApprovalDialog
+      include Clacky::RichUI::Components::BaseComponent
+
+      RISK_LEVELS = {
+        low:      { label: "Low",      color: :green,  bar: "●○○○" },
+        medium:   { label: "Medium",   color: :yellow, bar: "●●○○" },
+        high:     { label: "High",     color: :yellow, bar: "●●●○" },
+        critical: { label: "Critical", color: :red,    bar: "●●●●" }
+      }.freeze
+
+      CATEGORY_COLORS = {
+        file: :blue, shell: :yellow, network: :cyan, paid: :magenta
+      }.freeze
+
+      CHOICES = [
+        { key: :approve,       label: "Approve",       color: :green  },
+        { key: :deny,          label: "Deny",           color: :red    },
+        { key: :always_allow,  label: "Always allow",   color: :cyan   }
+      ].freeze
+
+      attr_accessor :width, :height
+
+      def initialize(tool_name:, message:, params: {}, risk: :medium, category: :file)
+        @tool_name = tool_name
+        @message = message
+        @params = params
+        @risk = RISK_LEVELS[risk] || RISK_LEVELS[:medium]
+        @category = category
+        @category_color = CATEGORY_COLORS[category] || :blue
+        @selected_index = 0
+        @width = 72
+        @height = [params.length + 10, 12].max
+        @event_listeners = {}
+        @mutex = Mutex.new
+        @condition = ConditionVariable.new
+        @finished = false
+        @result = nil
+        @panel = RubyRich::Panel.new("", title: "Approval", border_style: @risk[:color], title_align: :center)
+        @layout = RubyRich::Layout.new(name: :approval_dialog, width: @width, height: @height)
+        @layout.update_content(@panel)
+        @layout.calculate_dimensions(@width, @height)
+        wire_keys
+      end
+
+      def finish(value)
+        @mutex.synchronize do
+          @result = value
+          @finished = true
+          @condition.signal
+        end
+        true
+      end
+
+      def wait
+        @mutex.synchronize { @condition.wait(@mutex) until @finished }
+        @result
+      end
+
+      def key(event_name, priority = 0, &block)
+        @event_listeners[event_name] ||= []
+        @event_listeners[event_name] << { priority: priority, block: block }
+        @event_listeners[event_name].sort_by! { |l| -l[:priority] }
+      end
+
+      def notify_listeners(event_data)
+        Array(@event_listeners[event_data[:name]]).each { |l| l[:block].call(event_data, nil) }
+      end
+
+      def render_to_buffer
+        @panel.content = render_content
+        @layout.calculate_dimensions(@width, @height)
+        @layout.render_to_buffer
+      end
+
+      private def wire_keys
+        key(:left,  100) { move_selection(-1); true }
+        key(:right, 100) { move_selection(1);  true }
+        key(:string, 100) do |event, _live|
+          case event[:value]
+          when "h" then move_selection(-1)
+          when "l" then move_selection(1)
+          end
+          true
+        end
+        key(:enter, 100) do
+          sel = CHOICES[@selected_index]
+          finish(sel ? sel[:key] : :deny)
+        end
+        key(:escape, 100) { finish(:deny) }
+        key(:ctrl_c, 100) { finish(:deny) }
+      end
+
+      def move_selection(delta)
+        @selected_index = (@selected_index + delta) % CHOICES.length
+      end
+
+      def render_content
+        risk = @risk
+        lines = []
+        lines << ""
+        lines << "  #{colored("Tool:",  :body)}  #{colored(@tool_name, :accent)}  #{category_badge}"
+        lines << "  #{colored("Risk:",  :body)}  #{colored(risk[:label], risk[:color])} #{colored(risk[:bar], risk[:color])}"
+        lines << "  #{colored("Info:",  :body)}  #{colored(@message, :body)}"
+
+        unless @params.empty?
+          lines << ""
+          @params.each do |key, value|
+            val = value.to_s
+            val = "#{val[0..50]}..." if val.length > 54
+            lines << "  #{muted("#{key}:")}  #{colored(val, :body)}"
+          end
+        end
+
+        lines << ""
+        lines << render_choices
+        lines << ""
+        lines.join("\n")
+      end
+
+      def render_choices
+        CHOICES.each_with_index.map do |choice, i|
+          selected = i == @selected_index
+          prefix = selected ? "#{RubyRich::AnsiCode.color(:cyan, true)}➜#{RubyRich::AnsiCode.reset}" : " "
+          label = selected ? colored(choice[:label], choice[:color]) : muted(choice[:label])
+          "#{prefix} [#{label}]"
+        end.join("  ")
+      end
+
+      def category_badge
+        label = @category.to_s.capitalize
+        colored("[#{label}]", @category_color)
+      end
+    end
+  end
+end

data/lib/clacky/rich_ui/components/dialogs/config_menu_dialog.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "ruby_rich"
+require_relative "../base_component"
+
+module Clacky
+    module RichUI
+      class ConfigMenuDialog
+      include Clacky::RichUI::Components::BaseComponent
+
+      attr_accessor :width, :height
+
+      def initialize(choices:, selected_index: 0, title: "Model Configuration", width: 86)
+        @choices = choices
+        @selected_index = selected_index
+        @width = width
+        @height = [choices.length + 7, 12].max
+        @event_listeners = {}
+        @mutex = Mutex.new
+        @condition = ConditionVariable.new
+        @finished = false
+        @result = nil
+        @panel = RubyRich::Panel.new("", title: title, border_style: :cyan, title_align: :center)
+        @layout = RubyRich::Layout.new(name: :config_dialog, width: @width, height: @height)
+        @layout.update_content(@panel)
+        @layout.calculate_dimensions(@width, @height)
+      end
+
+      def selected_choice
+        @choices[@selected_index]
+      end
+
+      def move_up
+        move(-1)
+      end
+
+      def move_down
+        move(1)
+      end
+
+      def finish(value)
+        @mutex.synchronize do
+          @result = value
+          @finished = true
+          @condition.signal
+        end
+        true
+      end
+
+      def wait
+        @mutex.synchronize { @condition.wait(@mutex) until @finished }
+        @result
+      end
+
+      def key(event_name, priority = 0, &block)
+        @event_listeners[event_name] ||= []
+        @event_listeners[event_name] << { priority: priority, block: block }
+        @event_listeners[event_name].sort_by! { |listener| -listener[:priority] }
+      end
+
+      def notify_listeners(event_data)
+        Array(@event_listeners[event_data[:name]]).each { |listener| listener[:block].call(event_data, nil) }
+      end
+
+      def render_to_buffer
+        @panel.content = render_content
+        @layout.calculate_dimensions(@width, @height)
+        @layout.render_to_buffer
+      end
+
+      def move(delta)
+        return if @choices.empty?
+
+        index = @selected_index
+        loop do
+          index = (index + delta) % @choices.length
+          break unless @choices[index][:disabled]
+          break if index == @selected_index
+        end
+        @selected_index = index
+      end
+
+      def render_content
+        lines = [""]
+        @choices.each_with_index do |choice, index|
+          lines << choice_line(choice, selected: index == @selected_index)
+        end
+        lines << ""
+        lines << "#{muted("↑↓/jk: Navigate")} • #{muted("Enter: Select")} • #{muted("Esc/q: Cancel")}"
+        lines.join("\n")
+      end
+
+      def choice_line(choice, selected:)
+        return "  #{muted(choice[:label])}" if choice[:disabled]
+
+        prefix = selected ? "#{RubyRich::AnsiCode.color(:cyan, true)}➜#{RubyRich::AnsiCode.reset} " : "  "
+        label = selected ? RubyRich::AnsiCode.color(:white, true) + choice[:label] + RubyRich::AnsiCode.reset : choice[:label]
+        "#{prefix}#{label}"
+      end
+
+      private :move,
+              :render_content,
+              :choice_line
+    end
+  end
+end

data/lib/clacky/rich_ui/components/dialogs/form_dialog.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "ruby_rich"
+require_relative "../base_component"
+
+module Clacky
+    module RichUI
+      class FormDialog
+      include Clacky::RichUI::Components::BaseComponent
+
+      attr_accessor :width, :height
+
+      def initialize(title:, fields:, width: 92)
+        @title = title
+        @fields = fields
+        @field_index = 0
+        @editors = fields.map do |field|
+          RubyRich::LineEditor.new.tap { |editor| editor.value = field[:default].to_s }
+        end
+        @width = width
+        @height = [fields.length * 3 + 8, 16].max
+        @event_listeners = {}
+        @mutex = Mutex.new
+        @condition = ConditionVariable.new
+        @finished = false
+        @result = nil
+        @panel = RubyRich::Panel.new("", title: title, border_style: :cyan, title_align: :center)
+        @layout = RubyRich::Layout.new(name: :form_dialog, width: @width, height: @height)
+        @layout.update_content(@panel)
+        @layout.calculate_dimensions(@width, @height)
+        wire_default_keys
+      end
+
+      def finish(value)
+        @mutex.synchronize do
+          @result = value
+          @finished = true
+          @condition.signal
+        end
+        true
+      end
+
+      def wait
+        @mutex.synchronize { @condition.wait(@mutex) until @finished }
+        @result
+      end
+
+      def key(event_name, priority = 0, &block)
+        @event_listeners[event_name] ||= []
+        @event_listeners[event_name] << { priority: priority, block: block }
+        @event_listeners[event_name].sort_by! { |listener| -listener[:priority] }
+      end
+
+      def notify_listeners(event_data)
+        listeners = Array(@event_listeners[event_data[:name]])
+        listeners.each { |listener| listener[:block].call(event_data, nil) }
+      end
+
+      def render_to_buffer
+        @panel.content = render_content
+        @layout.calculate_dimensions(@width, @height)
+        @layout.render_to_buffer
+      end
+
+      def wire_default_keys
+        key(:string, 100) { |event, _live| current_editor.insert(event[:value]); true }
+        key(:paste, 100) { |event, _live| current_editor.insert(event[:value]); true }
+        key(:backspace, 100) { current_editor.backspace; true }
+        key(:delete, 100) { current_editor.delete; true }
+        key(:left, 100) { current_editor.move_left; true }
+        key(:right, 100) { current_editor.move_right; true }
+        key(:ctrl_a, 100) { current_editor.buffer_start; true }
+        key(:ctrl_e, 100) { current_editor.buffer_end; true }
+        key(:up, 100) { move_field(-1); true }
+        key(:down, 100) { move_field(1); true }
+        key(:tab, 100) { move_field(1); true }
+        key(:shift_tab, 100) { move_field(-1); true }
+        key(:enter, 100) { finish(values); true }
+      end
+
+      def current_editor
+        @editors[@field_index]
+      end
+
+      def move_field(delta)
+        @field_index = (@field_index + delta) % @fields.length
+      end
+
+      def values
+        @fields.each_with_index.to_h { |field, index| [field[:name].to_sym, @editors[index].value] }
+      end
+
+      def render_content
+        lines = [""]
+        @fields.each_with_index do |field, index|
+          focused = index == @field_index
+          marker = focused ? "#{RubyRich::AnsiCode.color(:cyan, true)}➜#{RubyRich::AnsiCode.reset}" : " "
+          label = focused ? "#{RubyRich::AnsiCode.color(:white, true)}#{field[:label]}#{RubyRich::AnsiCode.reset}" : field[:label]
+          lines << "#{marker} #{label}"
+          lines << "  #{render_field_value(field, @editors[index], focused: focused)}"
+          lines << ""
+        end
+        lines << "#{muted("Tab/↑↓: Field")} • #{muted("Enter: Save")} • #{muted("Esc: Cancel")}"
+        lines.join("\n")
+      end
+
+      def render_field_value(field, editor, focused:)
+        raw = editor.value
+        text = if field[:mask] && !raw.empty?
+                 "*" * raw.length
+               elsif raw.empty?
+                 field[:placeholder].to_s
+               else
+                 raw
+               end
+        color = raw.empty? ? :black : (focused ? :cyan : :white)
+        "#{RubyRich::AnsiCode.color(color, true)}#{text}#{RubyRich::AnsiCode.reset}"
+      end
+
+      private :wire_default_keys,
+              :current_editor,
+              :move_field,
+              :values,
+              :render_content,
+              :render_field_value
+    end
+  end
+end

data/lib/clacky/rich_ui/components/sidebar.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "ruby_rich"
+require_relative "sidebar_panels"
+
+module Clacky
+  module RichUI
+    class RichSidebar
+      MODES = %i[work tasks context auto hidden].freeze
+      PANEL_HEIGHT_RATIOS = { 1 => [1.0], 2 => [0.5, 0.5], 3 => [0.34, 0.33, 0.33] }.freeze
+      PANEL_NAMES = { work: "Work", tasks: "Tasks", context: "Context" }.freeze
+
+      attr_accessor :width, :height
+      attr_reader :mode
+
+      def initialize
+        @mode = :auto
+        @panels = {
+          work: RichWorkPanel.new,
+          tasks: RichTasksPanel.new,
+          context: RichContextPanel.new
+        }
+        @width = 0
+        @height = 0
+      end
+
+      def update_plan(text)
+        @panels[:work].update_plan(text)
+        self
+      end
+
+      def set_tasks(tasks)
+        @panels[:tasks].set_tasks(tasks)
+        self
+      end
+
+      def update_context(token_data)
+        @panels[:context].update_tokens(token_data)
+        self
+      end
+
+      def update_work_activities(activities)
+        @panels[:work].update_activities(activities)
+        self
+      end
+
+      def update_work_stats(tasks, cost)
+        @panels[:work].update_stats(tasks, cost)
+      end
+
+      # Returns the tasks list from the tasks panel (for tests/assertions)
+      def tasks
+        @panels[:tasks].instance_variable_get(:@tasks)
+      end
+
+      def set_mode(mode)
+        @mode = MODES.include?(mode) ? mode : :auto
+      end
+
+      def render
+        visible = visible_panels
+        return [""] if visible.empty?
+
+        heights = panel_heights(visible)
+        panel_lines = visible.each_with_index.flat_map do |key, i|
+          panel = @panels[key]
+          panel.width = [@width - 2, 1].max
+          panel.height = heights[i]
+          p = RubyRich::Panel.new(panel.render, title: PANEL_NAMES[key], border_style: :blue, title_align: :left)
+          p.width = @width
+          p.height = heights[i]
+          p.render
+        end
+        panel_lines.first(@height)
+      end
+
+      private def visible_panels
+        case @mode
+        when :work then [:work]
+        when :tasks then [:tasks]
+        when :context then [:context]
+        when :hidden then []
+        when :auto
+          @panels.select { |_key, panel| panel_has_content?(panel) }.keys
+        else
+          []
+        end
+      end
+
+      def panel_heights(visible)
+        max_h = [@height, 1].max
+        # Context panel gets exactly 6 lines; remaining space split among others
+        ctx_idx = visible.index(:context)
+        if ctx_idx
+          ctx_h = [6, max_h / [visible.length, 1].max].min
+          other_count = visible.length - 1
+          other_h = other_count > 0 ? (max_h - ctx_h) / other_count : 0
+          visible.each_with_index.map { |_, i| i == ctx_idx ? ctx_h : [other_h, 1].max }
+        else
+          h = max_h / visible.length
+          visible.map { [h, 1].max }
+        end
+      end
+
+      def panel_has_content?(panel)
+        case panel
+        when RichWorkPanel
+          true  # Always show — shows "0 tasks · $0.0000" when empty
+        when RichTasksPanel
+          panel.has_tasks?
+        when RichContextPanel
+          true  # Always show — shows "No token data" when empty
+        else
+          false
+        end
+      end
+    end
+  end
+end