ruby_rich 0.4.0 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c81d8c96218da776dce71a58d8c6ab5065c106a0a6818ea7d73f16fb877e4e5c
-  data.tar.gz: f01f062343bcc4187861d2a984db97d624d2d810fd90f5f5720b446ad16fecaa
+  metadata.gz: a6389b429fa73b0aa3057ed437aa50e051bf1e9b7775a2f5ee4d0860fe1f2dbe
+  data.tar.gz: a0a2030db498d207fa27e4ba370da391afe654b2ba8c1998973a644c3ee324f3
 SHA512:
-  metadata.gz: c43c87d6fe89f77962a9a4ddfd5148b5ff97c1c81e5435ff39eac99ecdfa36efb270818db5aef4869b6d4feb947c7b859721d8f08aafea82a2fb582b4d0ca265
-  data.tar.gz: 6aa8944f0096c5af0ed9172a2e6fc85a97f97662b3ce7f54a3d55cf035686fba3a4ab98ed70f52411b3a2dfa320d2bc943e47ed3cbed7075965c5e5147ae0794
+  metadata.gz: bf56a855f9292e8eb03cbe2e5d71b0bef6be0de091b91f070c00a7cee14b989e50fc7ae98455f506e6667b2f3e846dc7e6bd0ff73653fc04f84fcd6fb3039a54
+  data.tar.gz: 0566e96e17f22b5499d867eebfb18d5519cda6336c4bc26531c0212eb763dd4df7aa90a362388bc31d837c0fbe2b3243873e341eb76a4b2d63135a936e79cbd6

data/lib/ruby_rich/agent_shell.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+require "thread"
+
+module RubyRich
+  class AgentShell < AppShell
+    attr_reader :mode
+
+    def initialize(**options)
+      @callbacks = {}
+      @state_mutex = Mutex.new
+      @id_mutex = Mutex.new
+      @pending_actions = Queue.new
+      @entry_sequence = 0
+      @state = :initialized
+      @ui_thread = nil
+      @mode = :chat
+      super
+      @stop_on_ctrl_c = false
+      @composer.instance_variable_set(:@on_interrupt, method(:handle_interrupt))
+      @composer.instance_variable_set(:@on_eof, method(:handle_eof))
+      attach_agent_controls
+    end
+
+    def on_submit(&block)
+      @callbacks[:submit] = block
+      self
+    end
+
+    def on_interrupt(&block)
+      @callbacks[:interrupt] = block
+      self
+    end
+
+    def on_mode_toggle(&block)
+      @callbacks[:mode_toggle] = block
+      self
+    end
+
+    def on_command(&block)
+      @callbacks[:command] = block
+      self
+    end
+
+    def start(refresh_rate: 24, mouse: true, alt_screen: false)
+      @state_mutex.synchronize { @state = :starting }
+      Live.start(@layout, refresh_rate: refresh_rate, mouse: mouse, alt_screen: alt_screen, autowrap: false) do |live|
+        @state_mutex.synchronize do
+          @live = live
+          @ui_thread = Thread.current
+          @state = :running
+        end
+        drain_pending_actions(live)
+        live.listening = true
+      end
+    ensure
+      @state_mutex.synchronize do
+        @live = nil
+        @ui_thread = nil
+        @state = :stopped
+      end
+    end
+
+    def stop
+      dispatch_after_start_failure = false
+      @state_mutex.synchronize do
+        return false if @state == :stopped
+
+        if @live
+          return @live.stop if Thread.current == @ui_thread
+
+          return @live.post { |live| live.stop } || false
+        end
+
+        @state = :stopped
+        dispatch_after_start_failure = true
+      end
+      dispatch_after_start_failure
+    end
+
+    def add_user_message(text)
+      add_message(:user, text)
+    end
+
+    def add_assistant_message(text, streaming: false)
+      add_message(:assistant, text, streaming: streaming)
+    end
+
+    def add_markdown(content, streaming: false)
+      add_message(:markdown, content, streaming: streaming)
+    end
+
+    def add_system_message(text)
+      add_message(:system, text)
+    end
+
+    def add_error_message(text)
+      add_message(:error, text)
+    end
+
+    def add_diff(title: nil, content:, language: "diff")
+      text = title ? "#{title}\n#{content}" : content
+      add_message(:diff, text, language: language)
+    end
+
+    def append_to_message(id, delta)
+      dispatch { @transcript.append_block(id, delta).tap { @viewport.scroll_to_bottom } }
+    end
+
+    def replace_message(id, text)
+      dispatch { @transcript.replace_block(id, text).tap { @viewport.scroll_to_bottom } }
+    end
+
+    def remove_entry(id)
+      dispatch { @transcript.remove_block(id).tap { @viewport.scroll_to_bottom } }
+    end
+
+    def start_tool_call(name:, input: nil, status: :running)
+      id = reserve_id(:tool)
+      return nil unless id
+
+      ok = dispatch do
+        @transcript.add_tool(name, status: status, result: tool_body(input: input), collapsed: false, id: id)
+        @viewport.scroll_to_bottom
+        id
+      end
+      ok ? id : nil
+    end
+
+    def update_tool_call(id, status: nil, output: nil, input: nil)
+      options = {}
+      options[:status] = status if status
+      text = output.nil? && input.nil? ? nil : tool_body(input: input, output: output)
+      dispatch do
+        block = @transcript.find_block(id)
+        next false unless block
+
+        text ||= block[:text]
+        @transcript.replace_block(id, text, **options).tap { @viewport.scroll_to_bottom }
+      end
+    end
+
+    def finish_tool_call(id, status: :done, output: nil)
+      update_tool_call(id, status: status, output: output)
+    end
+
+    def update_tasks(tasks)
+      dispatch { @sidebar.set_tasks(tasks) }
+    end
+
+    def update_status(text)
+      dispatch { @status = text.to_s }
+    end
+
+    def show_token_usage(input: nil, output: nil, total: nil, **extra)
+      dispatch { @token_usage = { input: input, output: output, total: total }.merge(extra).compact }
+    end
+
+    def stopped?
+      @state_mutex.synchronize { @state == :stopped }
+    end
+
+    private
+
+    def add_message(type, text, **options)
+      id = reserve_id(type)
+      return nil unless id
+
+      ok = dispatch do
+        @transcript.add_block(type, text, **options, id: id)
+        @viewport.scroll_to_bottom
+        id
+      end
+      ok ? id : nil
+    end
+
+    def reserve_id(type)
+      @state_mutex.synchronize { return nil if @state == :stopped }
+
+      @id_mutex.synchronize do
+        @entry_sequence += 1
+        "#{type}-#{@entry_sequence}"
+      end
+    end
+
+    def dispatch
+      state, live, ui_thread = @state_mutex.synchronize { [@state, @live, @ui_thread] }
+      return false if state == :stopped
+
+      if live
+        return yield if Thread.current == ui_thread
+
+        return live.post { yield }
+      end
+
+      if state == :starting
+        @pending_actions << proc { yield }
+        return true
+      end
+
+      yield
+    end
+
+    def drain_pending_actions(live)
+      @pending_actions.pop(true).call(live) until @pending_actions.empty?
+    rescue ThreadError
+      nil
+    end
+
+    def attach_agent_controls
+      @layout.key(:ctrl_c, 2_000) do |_event, live|
+        handle_interrupt(live, self)
+        false
+      end
+
+      @layout.key(:ctrl_m, 2_000) do |_event, _live|
+        toggle_mode
+        false
+      end
+    end
+
+    def handle_interrupt(_live = nil, _source = nil)
+      @callbacks[:interrupt]&.call(input_was_empty: @composer.value.to_s.empty?)
+    end
+
+    def handle_eof(live = nil, _source = nil)
+      @callbacks[:eof]&.call if @callbacks[:eof]
+      live&.stop
+    end
+
+    def handle_submit(value, live, attachments = [])
+      text = value.to_s
+      if text.start_with?("/")
+        command = text.split(/\s+/, 2).first
+        @callbacks[:command]&.call(command)
+      end
+
+      @callbacks[:submit]&.call(text, attachments)
+    end
+
+    def toggle_mode
+      @mode = @mode == :chat ? :agent : :chat
+      @callbacks[:mode_toggle]&.call(@mode)
+      @status = "mode · #{@mode}"
+    end
+
+    def tool_body(input: nil, output: nil)
+      parts = []
+      parts << "input:\n#{input}" unless input.nil? || input.to_s.empty?
+      parts << "output:\n#{output}" unless output.nil? || output.to_s.empty?
+      parts.join("\n")
+    end
+  end
+end

data/lib/ruby_rich/ansi_code.rb

@@ -62,10 +62,14 @@ module RubyRich
     }
 
     def self.reset
+      return "" unless color_enabled?
+
       ANSI_CODES[:reset]
     end
 
     def self.color(color, bright=false)
+      return "" unless color_enabled?
+
       if bright
         "\e[#{ANSI_CODES[:bright_color][color]}m"
       else
@@ -74,6 +78,8 @@ module RubyRich
     end
 
     def self.background(color, bright=false)
+      return "" unless color_enabled?
+
       if bright
         "\e[#{ANSI_CODES[:bright_background][color]}m"
       else
@@ -82,14 +88,26 @@ module RubyRich
     end
 
     def self.bold
+      return "" unless color_enabled?
+
       "\e[#{ANSI_CODES[:bold]}m"
     end
 
+    def self.faint
+      return "" unless color_enabled?
+
+      "\e[#{ANSI_CODES[:faint]}m"
+    end
+
     def self.italic
+      return "" unless color_enabled?
+
       "\e[#{ANSI_CODES[:italic]}m"
     end
 
     def self.underline(style=nil)
+      return "" unless color_enabled?
+
       case style
       when nil
         return "\e[#{ANSI_CODES[:underline]}m"
@@ -105,38 +123,56 @@ module RubyRich
     end
 
     def self.blink
+      return "" unless color_enabled?
+
       "\e[#{ANSI_CODES[:blink]}m"
     end
 
     def self.rapid_blink
+      return "" unless color_enabled?
+
       "\e[#{ANSI_CODES[:rapid_blink]}m"
     end
 
     def self.inverse
+      return "" unless color_enabled?
+
       "\e[#{ANSI_CODES[:inverse]}m"
     end
 
     def self.fraktur
+      return "" unless color_enabled?
+
       "\e[#{ANSI_CODES[:fraktur]}m"
     end
 
     def self.invisible
+      return "" unless color_enabled?
+
       "\e[#{ANSI_CODES[:invisible]}m"
     end
 
     def self.strikethrough
+      return "" unless color_enabled?
+
       "\e[#{ANSI_CODES[:strikethrough]}m"
     end
     
     def self.overline
+      return "" unless color_enabled?
+
       "\e[#{ANSI_CODES[:overline]}m"
     end
 
     def self.no_blink
+      return "" unless color_enabled?
+
       "\e[#{ANSI_CODES[:no_blink]}m"
     end
 
     def self.no_inverse
+      return "" unless color_enabled?
+
       "\e[#{ANSI_CODES[:no_inverse]}m"
     end
 
@@ -151,6 +187,8 @@ module RubyRich
       strikethrough: false,
       overline: false
       )
+      return "" unless color_enabled?
+
       code = if font_bright
         "\e[#{ANSI_CODES[:bright_color][font_color]}"
       else
@@ -191,5 +229,13 @@ module RubyRich
       end
       return code+"m"
     end
+
+    def self.color_enabled?
+      ENV["NO_COLOR"].nil? && ENV["TERM"] != "dumb" && @color_enabled != false
+    end
+
+    def self.color_enabled=(enabled)
+      @color_enabled = enabled
+    end
   end
 end