openclacky 1.3.2 → 1.3.4

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

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "ruby_rich"
+require_relative "base_component"
+
+module Clacky
+  module RichUI
+    class RichWorkPanel
+      include Components::BaseComponent
+
+      attr_accessor :width, :height
+
+      def initialize
+        @plan = ""
+        @activities = []
+        @tasks = 0
+        @cost = 0.0
+      end
+
+      def update_plan(text)
+        @plan = text.to_s
+      end
+
+      def update_activities(activities)
+        @activities = Array(activities).last(8)
+      end
+
+      def update_stats(tasks, cost)
+        @tasks = tasks.to_i
+        @cost = cost.to_f
+      end
+
+      def render
+        lines = []
+        lines << @plan unless @plan.empty?
+        unless @activities.empty?
+          lines << "" unless lines.empty?
+          @activities.each do |a|
+            marker = status_marker(a[:status] || :pending)
+            lines << "#{marker} #{a[:label]}"
+          end
+        end
+        lines << "" unless lines.empty?
+        lines << muted("#{@tasks} tasks · $#{@cost.round(4)}")
+        lines.join("\n")
+      end
+    end
+
+    class RichTasksPanel
+      include Components::BaseComponent
+
+      attr_accessor :width, :height
+
+      def initialize
+        @tasks = []
+      end
+
+      def set_tasks(tasks)
+        @tasks = Array(tasks)
+      end
+
+      def has_tasks?
+        !@tasks.empty?
+      end
+
+      def render
+        return muted("No active tasks") if @tasks.empty?
+
+        lines = []
+        done_count = 0
+        total = @tasks.length
+        @tasks.each do |task|
+          label = task_label(task)
+          status = task_status(task)
+          done_count += 1 if %i[done completed].include?(status)
+          lines << "#{status_marker(status)} #{label}"
+        end
+        lines << "" unless lines.empty?
+        lines << muted("#{done_count}/#{total} done")
+        lines.join("\n")
+      end
+
+      private def task_label(task)
+        case task
+        when Hash
+          (task[:label] || task["label"] || task[:title] || task["title"] ||
+           task[:content] || task["content"] || task[:task] || task["task"]).to_s
+        else
+          task.to_s
+        end
+      end
+
+      def task_status(task)
+        case task
+        when Hash then (task[:status] || task["status"] || :pending).to_sym
+        else :pending
+        end
+      end
+    end
+
+    class RichContextPanel
+      include Components::BaseComponent
+
+      attr_accessor :width, :height
+
+      def initialize
+        @token_usage = nil
+      end
+
+      def update_tokens(data)
+        @token_usage = data
+      end
+
+      def render
+        return muted("No token data") unless @token_usage
+
+        input  = @token_usage[:prompt_tokens] || @token_usage[:input]  || 0
+        output = @token_usage[:completion_tokens] || @token_usage[:output] || 0
+        total  = @token_usage[:total_tokens] || @token_usage[:total] || (input + output)
+        cost   = @token_usage[:cost]
+
+        lines = []
+        lines << "#{muted("prompt:")}   #{input} tok"
+        lines << "#{muted("output:")}  #{output} tok"
+        lines << "#{muted("total:")}   #{total} tok"
+        if cost
+          lines << ""
+          lines << "#{muted("cost:")}    $#{cost.round(4)}"
+        end
+        lines.join("\n")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "ruby_rich"
+
+module Clacky
+  module RichUI
+    class RichStatusView
+      SPINNER = ['|', '/', '-', '\\'].freeze
+
+      attr_accessor :width, :height
+
+      def initialize(shell)
+        @shell = shell
+        @spinner_index = 0
+        @width = 0
+        @height = 1
+      end
+
+      def render
+        theme = @shell.theme
+        clacky = @shell.clacky_controller
+        return [""] unless clacky
+
+        status = clacky.status || "idle"
+        tasks = clacky.tasks_count || 0
+        cost  = clacky.total_cost || 0.0
+        turn  = clacky.turn_active
+        ctrlc = clacky.ctrl_c_warning
+
+        mode    = clacky.config&.dig(:mode) || "agent"
+        model   = clacky.config&.dig(:model) || "—"
+        latency = clacky.latest_latency
+        model_str = latency ? "#{model} (#{latency})" : model
+        meta_right = "#{mode} · #{model_str}"
+
+        if ctrlc
+          line = "#{theme.style("⏎", :error)} #{theme.style(ctrlc, :error)}"
+        elsif turn
+          @spinner_index = (@spinner_index + 1) % SPINNER.length
+          spinner = theme.style(SPINNER[@spinner_index], :accent)
+          label  = clacky.work_label || "working…"
+          right  = "#{meta_right} · #{tasks} tasks · $#{cost.round(4)}"
+          left   = "#{spinner} #{theme.style(label, :body)}"
+        else
+          right = "#{meta_right} · #{tasks} tasks · $#{cost.round(4)} · Ctrl+C quit"
+          left  = theme.style(status || "idle", :accent)
+        end
+        space = [@width - visible_len(left) - visible_len(right) - 2, 1].max
+        line  = "#{left}#{" " * space}#{theme.style(right, :muted)}"
+        [line]
+      end
+
+      private def visible_len(text)
+        text.to_s.gsub(/\e\[[0-9;:]*m/, "").length
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "ruby_rich"
+
+module Clacky
+  module RichUI
+    class ThinkingLiveView
+      SPINNER = ['|', '/', '-', '\\'].freeze
+
+      attr_accessor :width, :height
+      attr_reader :start_time
+
+      def initialize(shell)
+        @shell = shell
+        @status = :idle     # :idle, :thinking, :done
+        @text = +""
+        @start_time = nil
+        @spinner_index = 0
+        @width = 0
+        @height = 0
+      end
+
+      def desired_height
+        @status == :idle ? 0 : 6
+      end
+
+      def start_thinking
+        @status = :thinking
+        @start_time = Time.now
+        @text = +""
+        @shell.live&.refresh
+      end
+
+      def append_text(delta)
+        @text << delta.to_s
+        @shell.live&.refresh
+      end
+
+      def finish_thinking
+        @status = :done
+        @shell.live&.refresh
+      end
+
+      def idle!
+        @status = :idle
+        @text = +""
+        @start_time = nil
+        @shell.live&.refresh
+      end
+
+      def render
+        theme = @shell.theme
+        case @status
+        when :idle
+          [""]
+        when :thinking
+          elapsed = @start_time ? (Time.now - @start_time).round(1) : 0.0
+          @spinner_index = (@spinner_index + 1) % SPINNER.length
+          spinner = theme.style(SPINNER[@spinner_index], :thinking)
+          time_str = theme.style("#{elapsed}s", :accent)
+          header = " #{spinner} #{theme.style("Thinking", :thinking)}  #{time_str}"
+          lines = [header]
+          visible = @text.to_s.split("\n").last(5)
+          visible.each { |l| lines << "  #{theme.style(l, :thinking)}" }
+          (5 - visible.length).times { lines << "" }
+          lines
+        when :done
+          elapsed = @start_time ? (Time.now - @start_time).round(1) : 0.0
+          header = " #{theme.style("Thinking done", :thinking)}  #{theme.style("#{elapsed}s", :accent)}"
+          lines = [header]
+          visible = @text.to_s.split("\n").last(4)
+          visible.each { |l| lines << "  #{theme.style(l, :muted)}" }
+          (4 - visible.length).times { lines << "" }
+          lines
+        end
+      end
+    end
+  end
+end

data/lib/clacky/rich_ui/entry_tracker.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Clacky
+  module RichUI
+    # Lightweight id-based entry tracker for RubyRich Transcript entries.
+    #
+    # Replaces the fragile @tool_ids stack with explicit id-based tracking.
+    # RubyRich's AgentShell already returns stable ids from start_tool_call
+    # and accepts ids on finish_tool_call / update_tool_call / remove_entry.
+    # EntryTracker wraps these with a semantic API and is ready for future
+    # expansion (tracking markdown blocks, thinking entries, etc.).
+    class EntryTracker
+      def initialize
+        @tool_stack = []       # ordered tool_call ids (push on start, pop on finish/error)
+        @entries = {}          # id => { type:, ... } for future cross-type tracking
+      end
+
+      # Record a newly started tool call.
+      # Returns the id for chaining convenience.
+      def register_tool(id)
+        @tool_stack << id
+        @entries[id] = { type: :tool_call }
+        id
+      end
+
+      # Pop and return the most recent tool_call id.
+      # Returns nil when the stack is empty (tool output without a preceding call).
+      def pop_tool_id
+        id = @tool_stack.pop
+        @entries.delete(id) if id
+        id
+      end
+
+      # The most recent tool_call id without popping.
+      def current_tool_id
+        @tool_stack.last
+      end
+
+      # Are there any pending (unfinished) tool calls?
+      def pending_tool?
+        !@tool_stack.empty?
+      end
+
+      # Remove a specific entry by id.
+      def remove(id)
+        @entries.delete(id)
+        @tool_stack.delete(id)
+      end
+
+      # Number of pending tool calls.
+      def pending_count
+        @tool_stack.length
+      end
+    end
+  end
+end

data/lib/clacky/rich_ui/layout_adapter.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Clacky
+  module RichUI
+    class LayoutAdapter
+      def initialize(shell)
+        @shell = shell
+      end
+
+      def clear_output
+        @shell.transcript.store.entries.clear
+        @shell.viewport.scroll_to_bottom
+      end
+    end
+  end
+end

data/lib/clacky/rich_ui/progress_handle_adapter.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Clacky
+  module RichUI
+    class ProgressHandleAdapter
+      def initialize(handle)
+        @handle = handle
+      end
+
+      def update(message: nil, metadata: nil)
+        _ = metadata
+        @handle.update(message.to_s) if message
+      end
+
+      def finish(final_message: nil)
+        final_message ? @handle.finish(final_message.to_s) : @handle.finish
+      end
+
+      def cancel
+        @handle.cancel
+      end
+    end
+  end
+end