ruby_coded 0.1.1

data/lib/ruby_coded/chat/command_handler/token_commands.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class CommandHandler
+      # Slash commands for displaying session token usage and cost reports.
+      module TokenCommands
+        private
+
+        def cmd_tokens(_rest)
+          breakdown = @state.session_cost_breakdown
+
+          if breakdown.empty?
+            @state.add_message(:system, "No token usage recorded yet.")
+            return
+          end
+
+          @state.add_message(:system, build_token_report(breakdown))
+        end
+
+        def build_token_report(breakdown)
+          lines = ["Session Token Usage & Cost Report", "═" * 50]
+          breakdown.each { |entry| lines << format_token_entry(entry) }
+          lines << ("─" * 50)
+          lines << format_token_totals(breakdown)
+          lines.join("\n")
+        end
+
+        def format_token_entry(entry)
+          lines = []
+          lines << "Model: #{entry[:model]}"
+
+          if entry[:input_price_per_million]
+            format_priced_entry(lines, entry)
+          else
+            format_unpriced_entry(lines, entry)
+          end
+
+          lines.join("\n")
+        end
+
+        def format_priced_entry(lines, entry)
+          append_base_priced_lines(lines, entry)
+          append_optional_priced_lines(lines, entry)
+          lines << subtotal_line(entry)
+        end
+
+        def append_base_priced_lines(lines, entry)
+          lines << priced_line("Input:   ", entry[:input_tokens], entry[:input_cost], entry[:input_price_per_million])
+          lines << priced_line("Output:  ", entry[:output_tokens], entry[:output_cost],
+                               entry[:output_price_per_million])
+        end
+
+        def append_optional_priced_lines(lines, entry)
+          optional_priced_fields.each do |label, tokens_key, cost_key, price_key|
+            next unless entry[tokens_key].positive?
+
+            lines << priced_line(label, entry[tokens_key], entry[cost_key], entry[price_key])
+          end
+        end
+
+        def optional_priced_fields
+          [
+            ["Thinking:", :thinking_tokens, :thinking_cost, :thinking_price_per_million],
+            ["Cached:  ", :cached_tokens, :cached_cost, :cached_input_price_per_million],
+            ["Cache wr:", :cache_creation_tokens, :cache_creation_cost, :cache_creation_price_per_million]
+          ]
+        end
+
+        def priced_line(label, tokens, cost, price_per_million)
+          "  #{label} #{format_num(tokens)} tokens  (#{format_usd(cost)} @ $#{price_per_million}/1M)"
+        end
+
+        def subtotal_line(entry)
+          "  Subtotal: #{format_num(entry_total_tokens(entry))} tokens  #{format_usd(entry[:total_cost])}"
+        end
+
+        def format_unpriced_entry(lines, entry)
+          lines << "  Input:    #{format_num(entry[:input_tokens])} tokens"
+          lines << "  Output:   #{format_num(entry[:output_tokens])} tokens"
+          append_optional_unpriced_lines(lines, entry)
+          lines << "  Subtotal: #{format_num(entry_total_tokens(entry))} tokens  (pricing unavailable)"
+        end
+
+        def append_optional_unpriced_lines(lines, entry)
+          lines << "  Thinking: #{format_num(entry[:thinking_tokens])} tokens" if entry[:thinking_tokens].positive?
+          lines << "  Cached:   #{format_num(entry[:cached_tokens])} tokens" if entry[:cached_tokens].positive?
+        end
+
+        def entry_total_tokens(entry)
+          entry[:input_tokens] + entry[:output_tokens] + entry[:thinking_tokens] +
+            entry[:cached_tokens] + entry[:cache_creation_tokens]
+        end
+
+        def format_token_totals(breakdown)
+          totals = compute_totals(breakdown)
+          format_totals_summary(totals)
+        end
+
+        def compute_totals(breakdown)
+          {
+            input: breakdown.sum { |e| e[:input_tokens] },
+            output: breakdown.sum { |e| e[:output_tokens] },
+            thinking: breakdown.sum { |e| e[:thinking_tokens] },
+            cost: total_cost(breakdown)
+          }
+        end
+
+        def total_cost(breakdown)
+          costs = breakdown.map { |e| e[:total_cost] }.compact
+          costs.empty? ? nil : costs.sum
+        end
+
+        def format_totals_summary(totals)
+          total_tokens = totals[:input] + totals[:output] + totals[:thinking]
+          "Total: #{format_num(total_tokens)} tokens (#{token_parts(totals)}) | Cost: #{cost_string(totals[:cost])}"
+        end
+
+        def token_parts(totals)
+          parts = ["↑#{format_num(totals[:input])}", "↓#{format_num(totals[:output])}"]
+          parts << "💭#{format_num(totals[:thinking])}" if totals[:thinking].positive?
+          parts.join(" ")
+        end
+
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/command_handler/token_formatting.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class CommandHandler
+      # Shared formatting helpers for token and cost display.
+      module TokenFormatting
+        private
+
+        def format_num(num)
+          num.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\1,').reverse
+        end
+
+        def format_usd(amount)
+          return "N/A" if amount.nil?
+
+          "$#{format("%.2f", amount)}"
+        end
+
+        def cost_string(cost)
+          cost ? format_usd(cost) : "N/A"
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/command_handler.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "ruby_llm"
+
+require_relative "command_handler/model_commands"
+require_relative "command_handler/history_commands"
+require_relative "command_handler/token_formatting"
+require_relative "command_handler/token_commands"
+require_relative "command_handler/agent_commands"
+require_relative "command_handler/plan_commands"
+
+module RubyCoded
+  module Chat
+    # Handles slash commands entered in the chat input.
+    # Base commands are always available; plugins can contribute
+    # additional commands via the plugin registry.
+    class CommandHandler
+      include ModelCommands
+      include HistoryCommands
+      include TokenFormatting
+      include TokenCommands
+      include AgentCommands
+      include PlanCommands
+
+      BASE_COMMANDS = {
+        "/help" => :cmd_help,
+        "/exit" => :cmd_exit,
+        "/quit" => :cmd_exit,
+        "/clear" => :cmd_clear,
+        "/model" => :cmd_model,
+        "/history" => :cmd_history,
+        "/tokens" => :cmd_tokens,
+        "/agent" => :cmd_agent,
+        "/plan" => :cmd_plan
+      }.freeze
+
+      HELP_TEXT = File.read(File.join(__dir__, "help.txt")).freeze
+
+      def initialize(state, llm_bridge:, user_config: nil, credentials_store: nil)
+        @state = state
+        @llm_bridge = llm_bridge
+        @user_config = user_config
+        @credentials_store = credentials_store
+        @commands = build_command_map
+      end
+
+      def handle(raw_input)
+        stripped = raw_input.strip
+        return if stripped.empty?
+
+        command, rest = stripped.split(" ", 2)
+        method_name = @commands[command.downcase]
+
+        if method_name
+          send(method_name, rest)
+        else
+          @state.add_message(:system, "Unknown command: #{command}. Type /help for available commands.")
+        end
+      end
+
+      private
+
+      def build_command_map
+        cmds = BASE_COMMANDS.dup
+        cmds.merge!(RubyCoded.plugin_registry.all_commands)
+        cmds
+      end
+
+      def cmd_help(_rest)
+        text = HELP_TEXT.dup
+        plugin_descs = RubyCoded.plugin_registry.all_command_descriptions
+        unless plugin_descs.empty?
+          text += "\nPlugin commands:\n"
+          plugin_descs.each { |cmd, desc| text += "  #{cmd.ljust(18)} #{desc}\n" }
+        end
+        @state.add_message(:system, text)
+      end
+
+      def cmd_exit(_rest)
+        @state.should_quit = true
+      end
+
+      def cmd_clear(_rest)
+        @state.clear_messages!
+        @state.add_message(:system, "Conversation cleared.")
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/help.txt

@@ -0,0 +1,28 @@
+Available commands:
+  /help              Show this help message
+  /model             Select a model from available providers
+  /model <name>      Switch directly to a named model
+  /model --all       Select from all models (including deprecated)
+  /clear             Clear the conversation history
+  /history           Show conversation summary
+  /tokens            Show detailed token usage and cost for this session
+  /agent             Show agent mode status
+  /agent on          Enable agent mode (tools for file operations)
+  /agent off         Disable agent mode (chat only)
+  /plan              Show plan mode status
+  /plan on           Enable plan mode (structured development planning)
+  /plan off          Disable plan mode (warns if unsaved plan)
+  /plan off --force  Disable plan mode discarding unsaved plan
+  /plan save [file]  Save current plan to a markdown file
+  /exit, /quit       Exit the chat
+
+Tool confirmations (agent mode):
+  [y] / Enter        Approve the current tool call
+  [n] / Esc          Reject the current tool call
+  [a]                Approve current and all future tool calls (yes to all)
+
+Plan clarification (plan mode):
+  [Up/Down]          Navigate options
+  [Enter]            Select highlighted option / send custom response
+  [Tab]              Switch between options and free text input
+  [Esc]              Skip clarification question

data/lib/ruby_coded/chat/input_handler/modal_inputs.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class InputHandler
+      # Handles input events for specialized UI modes:
+      # tool confirmation, plan clarification, model selection, streaming, and mouse.
+      module ModalInputs
+        private
+
+        def handle_tool_confirmation_mode(event)
+          return :quit if event.ctrl_c?
+          return :tool_rejected if event.esc?
+
+          char = event.to_s.downcase
+          return :tool_approved if event.enter? || char == "y"
+          return :tool_rejected if char == "n"
+          return :tool_approved_all if char == "a"
+
+          nil
+        end
+
+        def handle_plan_clarification_mode(event)
+          return :quit if event.ctrl_c?
+          return :plan_clarification_skip if event.esc?
+          return toggle_clarification_mode if event.tab?
+
+          if @state.clarification_input_mode == :custom
+            handle_clarification_custom_input(event)
+          else
+            handle_clarification_options_input(event)
+          end
+        end
+
+        def handle_clarification_options_input(event)
+          if event.up?
+            @state.clarification_up
+          elsif event.down?
+            @state.clarification_down
+          elsif event.enter?
+            return :plan_clarification_selected
+          end
+          nil
+        end
+
+        def handle_clarification_custom_input(event)
+          if event.enter?
+            return :plan_clarification_custom unless @state.clarification_custom_input.strip.empty?
+          elsif event.backspace?
+            @state.delete_last_clarification_char
+          else
+            char = event.to_s
+            @state.append_to_clarification_input(char) unless char.empty? || event.ctrl? || event.alt?
+          end
+          nil
+        end
+
+        def toggle_clarification_mode
+          @state.toggle_clarification_input_mode!
+          nil
+        end
+
+        def handle_model_select_mode(event)
+          return :quit if event.ctrl_c?
+          return :model_select_cancel if event.esc?
+          return :model_selected if event.enter?
+
+          handle_model_select_input(event)
+          nil
+        end
+
+        def handle_model_select_input(event)
+          if event.up?
+            @state.model_select_up
+          elsif event.down?
+            @state.model_select_down
+          elsif event.backspace?
+            @state.delete_last_filter_char
+          else
+            append_filter_character(event)
+          end
+        end
+
+        def handle_streaming_mode(event)
+          return :quit if event.ctrl_c?
+          return :cancel_streaming if event.esc?
+          return :scroll_up if event.up? || event.page_up?
+          return :scroll_down if event.down? || event.page_down?
+
+          nil
+        end
+
+        def handle_mouse(event)
+          return :scroll_up if event.scroll_up?
+          return :scroll_down if event.scroll_down?
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/input_handler/normal_mode_input.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class InputHandler
+      # Handles input events for normal chat mode:
+      # text editing, cursor movement, scrolling, paste, and plugin dispatch.
+      module NormalModeInput
+        private
+
+        def handle_normal_mode(event)
+          return :quit if event.ctrl_c?
+
+          plugin_action = try_plugin_inputs(event)
+          return plugin_action if plugin_action
+
+          return submit if event.enter?
+          return backspace if event.backspace?
+          return clear_input if event.esc?
+
+          scroll_or_append(event)
+        end
+
+        # Runs each plugin's input handler in registration order.
+        # Returns the first non-nil action, or nil if no plugin handled it.
+        def try_plugin_inputs(event)
+          RubyCoded.plugin_registry.input_handler_configs.each do |config|
+            result = send(config[:method], event)
+            return result if result
+          end
+          nil
+        end
+
+        def scroll_or_append(event)
+          scroll = detect_scroll(event)
+          return scroll if scroll
+          return move_cursor_left if event.left?
+          return move_cursor_right if event.right?
+          return move_cursor_home if event.home?
+          return move_cursor_end if event.end?
+
+          append_character(event)
+        end
+
+        def detect_scroll(event)
+          return :scroll_up if event.up? || event.page_up?
+
+          :scroll_down if event.down? || event.page_down?
+        end
+
+        def submit
+          return nil if @state.input_buffer.strip.empty?
+
+          :submit
+        end
+
+        def backspace
+          @state.delete_last_char
+          nil
+        end
+
+        def clear_input
+          @state.clear_input!
+          nil
+        end
+
+        def move_cursor_left
+          @state.move_cursor_left
+          nil
+        end
+
+        def move_cursor_right
+          @state.move_cursor_right
+          nil
+        end
+
+        def move_cursor_home
+          @state.move_cursor_to_start
+          nil
+        end
+
+        def move_cursor_end
+          @state.move_cursor_to_end
+          nil
+        end
+
+        def append_character(event)
+          char = event.to_s
+          return nil if char.empty?
+          return nil if event.ctrl? || event.alt?
+
+          @state.append_to_input(char)
+          nil
+        end
+
+        def append_filter_character(event)
+          char = event.to_s
+          return if char.empty?
+          return if event.ctrl? || event.alt?
+
+          @state.append_to_model_filter(char)
+        end
+
+        def handle_paste(event)
+          text = event.content.tr("\n", " ")
+          if @state.model_select?
+            @state.append_to_model_filter(text) unless text.empty?
+          else
+            @state.append_to_input(text) unless text.empty?
+          end
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/input_handler.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "ratatui_ruby"
+
+require_relative "input_handler/modal_inputs"
+require_relative "input_handler/normal_mode_input"
+
+module RubyCoded
+  module Chat
+    # This class is used to handle the input events for the chat
+    class InputHandler
+      include ModalInputs
+      include NormalModeInput
+
+      def initialize(state)
+        @state = state
+      end
+
+      def process(event)
+        return handle_paste(event) if event.is_a?(RatatuiRuby::Event::Paste)
+        return handle_mouse(event) if event.is_a?(RatatuiRuby::Event::Mouse)
+        return nil unless event.key?
+
+        dispatch_key_event(event)
+      end
+
+      private
+
+      def dispatch_key_event(event)
+        return handle_tool_confirmation_mode(event) if @state.awaiting_tool_confirmation?
+        return handle_plan_clarification_mode(event) if @state.plan_clarification?
+        return handle_model_select_mode(event) if @state.model_select?
+        return handle_streaming_mode(event) if @state.streaming?
+
+        handle_normal_mode(event)
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/llm_bridge/plan_mode.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class LLMBridge
+      # Plan mode configuration, auto-switching to agent, and clarification handling.
+      module PlanMode
+        IMPLEMENTATION_PATTERNS = [
+          /\bimplement/i,
+          /\bgo ahead/i,
+          /\bproceed/i,
+          /\bexecut/i,
+          /\bejecutar?/i,
+          /\bcomenz/i,
+          /\bcomienz/i,
+          /\bhazlo/i,
+          /\bconstru[iy]/i,
+          /\badelante/i,
+          /\bdale\b/i,
+          /\bdo it/i,
+          /\bbuild it/i
+        ].freeze
+
+        private
+
+        def should_auto_switch_to_agent?(input)
+          @plan_mode && @state.current_plan && implementation_request?(input)
+        end
+
+        def implementation_request?(input)
+          IMPLEMENTATION_PATTERNS.any? { |pattern| input.match?(pattern) }
+        end
+
+        def auto_switch_to_agent!
+          toggle_agentic_mode!(true)
+          @state.add_message(:system,
+                             "Plan mode disabled — switching to agent mode to implement the plan.")
+        end
+
+        def configure_plan!(chat)
+          readonly_tools = @tool_registry.build_readonly_tools
+          chat.with_tools(*readonly_tools, replace: true)
+          chat.with_instructions(Tools::PlanSystemPrompt.build(project_root: @project_root))
+
+          chat.on_tool_call { |tool_call| handle_tool_call(tool_call) }
+          chat.on_tool_result { |result| handle_tool_result(result) }
+        end
+
+        def post_process_plan_response
+          last_msg = @state.messages_snapshot.last
+          return unless last_msg && last_msg[:role] == :assistant
+
+          content = last_msg[:content]
+          if PlanClarificationParser.clarification?(content)
+            handle_plan_clarification(content)
+          else
+            @state.update_current_plan!(content)
+          end
+        end
+
+        def handle_plan_clarification(content)
+          parsed = PlanClarificationParser.parse(content)
+          return unless parsed
+
+          stripped = PlanClarificationParser.strip_clarification(content)
+          @state.reset_last_assistant_content
+          @state.append_to_last_message(stripped) unless stripped.empty?
+          @state.enter_plan_clarification!(parsed[:question], parsed[:options])
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/llm_bridge/streaming_retries.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class LLMBridge
+      # Manages streaming responses, retry logic, and error recovery.
+      module StreamingRetries
+        private
+
+        def prepare_streaming
+          @cancel_requested = false
+          @state.streaming = true
+          @state.add_message(:assistant, "")
+          @chat_mutex.synchronize { @chat }
+        end
+
+        def update_response_tokens(response)
+          return unless response && !@cancel_requested && response.respond_to?(:input_tokens)
+
+          @state.update_last_message_tokens(
+            input_tokens: response.input_tokens,
+            output_tokens: response.output_tokens,
+            thinking_tokens: response.respond_to?(:thinking_tokens) ? response.thinking_tokens : nil,
+            cached_tokens: response.respond_to?(:cached_tokens) ? response.cached_tokens : nil,
+            cache_creation_tokens: response.respond_to?(:cache_creation_tokens) ? response.cache_creation_tokens : nil
+          )
+        end
+
+        def attempt_with_retries(chat, input, retries = 0)
+          stream_response(chat, input, retries)
+        rescue Tools::AgentCancelledError, Tools::AgentIterationLimitError, RubyCoded::Tools::ToolRejectedError => e
+          @state.add_message(:system, e.message)
+          nil
+        rescue RubyLLM::RateLimitError => e
+          retry if (retries = handle_rate_limit_retry(e, retries))
+          handle_api_failure(e, rate_limit_user_message(e))
+        rescue StandardError => e
+          handle_api_failure(e, generic_api_error_message(e))
+        end
+
+        def handle_api_failure(error, message)
+          @state.fail_last_assistant(error, friendly_message: message)
+          nil
+        end
+
+        def stream_response(chat, input, retries)
+          block = streaming_block
+          retries.zero? ? chat.ask(input, &block) : chat.complete(&block)
+        end
+
+        def streaming_block
+          proc do |chunk|
+            break if @cancel_requested
+
+            @state.streaming_append(chunk.content) if chunk.content
+          end
+        end
+
+        def handle_rate_limit_retry(error, retries)
+          return unless retries < MAX_RATE_LIMIT_RETRIES && !@cancel_requested
+
+          retries += 1
+          delay = RATE_LIMIT_BASE_DELAY * (2**(retries - 1))
+          @state.fail_last_assistant(
+            error,
+            friendly_message: "Rate limit alcanzado. Reintentando en #{delay}s... (#{retries}/#{MAX_RATE_LIMIT_RETRIES})"
+          )
+          sleep(delay)
+          @state.reset_last_assistant_content
+          retries
+        end
+
+        def rate_limit_user_message(error)
+          <<~MSG.strip
+            Límite de peticiones del proveedor (rate limit). Espera un minuto y vuelve a intentar; si se repite, revisa cuotas y plan en la consola de tu API (OpenAI, Anthropic, etc.).
+            Detalle: #{error.message}
+          MSG
+        end
+
+        def generic_api_error_message(error)
+          "No se pudo obtener respuesta del modelo: #{error.message}"
+        end
+      end
+    end
+  end
+end