ruby_coded 0.1.1

data/lib/ruby_coded/chat/state/model_selection.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class State
+      # This module contains the logic for the model selection management
+      module ModelSelection
+        def model_select?
+          @mode == :model_select
+        end
+
+        def model_select_show_all?
+          @model_select_show_all == true
+        end
+
+        def enter_model_select!(models, show_all: false)
+          @model_list = models
+          @model_select_index = 0
+          @model_select_filter = String.new
+          @model_select_show_all = show_all
+          @mode = :model_select
+          mark_dirty!
+        end
+
+        def exit_model_select!
+          @mode = :chat
+          @model_list = []
+          @model_select_index = 0
+          @model_select_filter = String.new
+          @model_select_show_all = false
+          mark_dirty!
+        end
+
+        def model_select_up
+          filtered = filtered_model_list
+          return if filtered.empty?
+
+          @model_select_index = (@model_select_index - 1) % filtered.size
+          mark_dirty!
+        end
+
+        def model_select_down
+          filtered = filtered_model_list
+          return if filtered.empty?
+
+          @model_select_index = (@model_select_index + 1) % filtered.size
+          mark_dirty!
+        end
+
+        def selected_model
+          filtered_model_list[@model_select_index]
+        end
+
+        def filtered_model_list
+          return @model_list if @model_select_filter.empty?
+
+          query = @model_select_filter.downcase
+          @model_list.select do |m|
+            model_id = m.respond_to?(:id) ? m.id : m.to_s
+            provider = m.respond_to?(:provider) ? m.provider.to_s : ""
+            model_id.downcase.include?(query) || provider.downcase.include?(query)
+          end
+        end
+
+        def append_to_model_filter(text)
+          @model_select_filter << text
+          @model_select_index = 0
+          mark_dirty!
+        end
+
+        def delete_last_filter_char
+          @model_select_filter.chop!
+          @model_select_index = 0
+          mark_dirty!
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/state/plan_tracking.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class State
+      # Manages plan mode state and the clarification UI flow.
+      # Plan mode tracks the current plan in memory and exposes
+      # a clarification overlay (similar to ModelSelection) when
+      # the LLM needs user input before generating the plan.
+      module PlanTracking
+        attr_reader :clarification_question, :clarification_options,
+                    :clarification_index, :clarification_custom_input,
+                    :clarification_input_mode
+
+        def init_plan_tracking
+          @plan_mode_active = false
+          @current_plan = nil
+          @plan_saved = true
+          reset_clarification_state
+        end
+
+        # --- Plan mode ---
+
+        def plan_mode_active?
+          @plan_mode_active
+        end
+
+        def activate_plan_mode!
+          @plan_mode_active = true
+        end
+
+        def deactivate_plan_mode!
+          @plan_mode_active = false
+          @current_plan = nil
+          @plan_saved = true
+          reset_clarification_state
+        end
+
+        def update_current_plan!(content)
+          @mutex.synchronize do
+            @current_plan = content
+            @plan_saved = false
+          end
+        end
+
+        def current_plan
+          @mutex.synchronize { @current_plan }
+        end
+
+        def plan_saved?
+          @mutex.synchronize { @plan_saved }
+        end
+
+        def mark_plan_saved!
+          @mutex.synchronize { @plan_saved = true }
+        end
+
+        def has_unsaved_plan?
+          @mutex.synchronize { @current_plan && !@plan_saved }
+        end
+
+        def clear_plan!
+          @mutex.synchronize do
+            @current_plan = nil
+            @plan_saved = true
+          end
+        end
+
+        # --- Clarification UI (pattern: ModelSelection) ---
+
+        def plan_clarification?
+          @mode == :plan_clarification
+        end
+
+        def enter_plan_clarification!(question, options)
+          @mutex.synchronize do
+            @clarification_question = question
+            @clarification_options = options
+            @clarification_index = 0
+            @clarification_custom_input = String.new
+            @clarification_input_mode = :options
+            @mode = :plan_clarification
+            @dirty = true
+          end
+        end
+
+        def exit_plan_clarification!
+          @mutex.synchronize do
+            @mode = :chat
+            reset_clarification_state
+            @dirty = true
+          end
+        end
+
+        def clarification_up
+          return if @clarification_options.empty?
+
+          @clarification_index = (@clarification_index - 1) % @clarification_options.size
+          mark_dirty!
+        end
+
+        def clarification_down
+          return if @clarification_options.empty?
+
+          @clarification_index = (@clarification_index + 1) % @clarification_options.size
+          mark_dirty!
+        end
+
+        def selected_clarification_option
+          @clarification_options[@clarification_index]
+        end
+
+        def toggle_clarification_input_mode!
+          @clarification_input_mode = @clarification_input_mode == :options ? :custom : :options
+          mark_dirty!
+        end
+
+        def append_to_clarification_input(text)
+          @clarification_custom_input << text
+          mark_dirty!
+        end
+
+        def delete_last_clarification_char
+          @clarification_custom_input.chop!
+          mark_dirty!
+        end
+
+        private
+
+        def reset_clarification_state
+          @clarification_question = nil
+          @clarification_options = []
+          @clarification_index = 0
+          @clarification_custom_input = String.new
+          @clarification_input_mode = :options
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/state/scrollable.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class State
+      # This module contains the logic for the scrollable management.
+      # scroll_offset represents "lines from the bottom": 0 = latest content visible.
+      module Scrollable
+        def scroll_up(amount = 1)
+          @scroll_offset = [@scroll_offset + amount, max_scroll].min
+          mark_dirty!
+        end
+
+        def scroll_down(amount = 1)
+          @scroll_offset = [@scroll_offset - amount, 0].max
+          mark_dirty!
+        end
+
+        def scroll_to_top
+          @scroll_offset = max_scroll
+          mark_dirty!
+        end
+
+        def scroll_to_bottom
+          @scroll_offset = 0
+          mark_dirty!
+        end
+
+        def update_scroll_metrics(total_lines:, visible_height:)
+          @total_lines = total_lines
+          @visible_height = visible_height
+        end
+
+        private
+
+        def max_scroll
+          [@total_lines - @visible_height, 0].max
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/state/token_cost.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "ruby_llm"
+
+module RubyCoded
+  module Chat
+    class State
+      # Provides session cost calculation based on token usage and model pricing.
+      # Looks up per-model pricing via RubyLLM's model registry.
+      # Accounts for thinking/reasoning tokens, cached input reads, and
+      # cache creation tokens in addition to regular input/output.
+      module TokenCost
+        # Anthropic charges 1.25× input price for cache writes.
+        # OpenAI reports cache_creation as 0, so this only affects Anthropic.
+        CACHE_CREATION_INPUT_MULTIPLIER = 1.25
+
+        UNPRICED_DEFAULTS = {
+          input_price_per_million: nil, output_price_per_million: nil,
+          thinking_price_per_million: nil, cached_input_price_per_million: nil,
+          cache_creation_price_per_million: nil,
+          input_cost: nil, output_cost: nil, thinking_cost: nil,
+          cached_cost: nil, cache_creation_cost: nil, total_cost: nil
+        }.freeze
+
+        def init_token_cost
+          @model_price_cache = {}
+        end
+
+        # Returns an array of cost breakdown hashes, one per model used.
+        # Cost fields are nil when pricing is unavailable.
+        def session_cost_breakdown
+          token_usage_by_model.map do |model_name, usage|
+            pricing = fetch_model_pricing(model_name)
+            build_cost_entry(model_name, usage, pricing)
+          end
+        end
+
+        def total_session_cost
+          breakdown = session_cost_breakdown
+          costs = breakdown.map { |entry| entry[:total_cost] }.compact
+          return nil if costs.empty?
+
+          costs.sum
+        end
+
+        private
+
+        def fetch_model_pricing(model_name)
+          return @model_price_cache[model_name] if @model_price_cache.key?(model_name)
+
+          info = RubyLLM.models.find(model_name)
+          pricing = if info.respond_to?(:input_price_per_million) && info.input_price_per_million
+                      build_pricing_hash(info)
+                    end
+          @model_price_cache[model_name] = pricing
+          pricing
+        rescue StandardError
+          @model_price_cache[model_name] = nil
+          nil
+        end
+
+        def build_pricing_hash(info)
+          input_price = info.input_price_per_million.to_f
+          output_price = info.output_price_per_million.to_f
+          text_tokens = info.pricing.text_tokens
+
+          {
+            input_price_per_million: input_price,
+            output_price_per_million: output_price,
+            thinking_price_per_million: resolve_thinking_price(text_tokens, output_price),
+            cached_input_price_per_million: resolve_cached_price(text_tokens),
+            cache_creation_price_per_million: input_price * CACHE_CREATION_INPUT_MULTIPLIER
+          }
+        end
+
+        def resolve_cached_price(text_tokens)
+          return unless text_tokens.respond_to?(:cached_input) && text_tokens.cached_input
+
+          text_tokens.cached_input.to_f
+        end
+
+        def resolve_thinking_price(text_tokens, output_price)
+          standard = text_tokens.standard
+          if standard.respond_to?(:reasoning_output_per_million) && standard.reasoning_output_per_million
+            standard.reasoning_output_per_million.to_f
+          else
+            output_price
+          end
+        end
+
+        def build_cost_entry(model_name, usage, pricing)
+          if pricing
+            build_priced_entry(model_name, usage, pricing)
+          else
+            build_unpriced_entry(model_name, usage)
+          end
+        end
+
+        def build_priced_entry(model_name, usage, pricing)
+          costs = compute_entry_costs(usage, pricing)
+          { model: model_name, **usage, **pricing, **costs, total_cost: costs.values.sum }
+        end
+
+        def compute_entry_costs(usage, pricing)
+          {
+            input_cost: token_cost(usage[:input_tokens], pricing[:input_price_per_million]),
+            output_cost: token_cost(usage[:output_tokens], pricing[:output_price_per_million]),
+            thinking_cost: token_cost(usage[:thinking_tokens], pricing[:thinking_price_per_million]),
+            cached_cost: cached_token_cost(usage[:cached_tokens], pricing[:cached_input_price_per_million]),
+            cache_creation_cost: token_cost(usage[:cache_creation_tokens], pricing[:cache_creation_price_per_million])
+          }
+        end
+
+        def cached_token_cost(tokens, price)
+          price ? token_cost(tokens, price) : 0.0
+        end
+
+        def build_unpriced_entry(model_name, usage)
+          { model: model_name, **usage, **UNPRICED_DEFAULTS }
+        end
+
+        def token_cost(count, price_per_million)
+          (count.to_f / 1_000_000) * price_per_million
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/state/tool_confirmation.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class State
+      # Manages the tool confirmation flow as inline chat messages.
+      # When a destructive tool is requested, a :tool_pending message
+      # is added to the conversation; the user approves or rejects
+      # via keyboard, and the message is updated in place.
+      #
+      # The user can press [a] to approve all future tool calls for
+      # the current session, bypassing individual confirmations.
+      module ToolConfirmation
+        attr_reader :tool_cv
+
+        def init_tool_confirmation
+          @pending_tool_name = nil
+          @pending_tool_args = nil
+          @tool_confirmation_response = nil
+          @auto_approve_tools = false
+          @tool_cv = ConditionVariable.new
+        end
+
+        def awaiting_tool_confirmation?
+          @mode == :tool_confirmation
+        end
+
+        def auto_approve_tools?
+          @auto_approve_tools
+        end
+
+        def enable_auto_approve!
+          @auto_approve_tools = true
+        end
+
+        def disable_auto_approve!
+          @auto_approve_tools = false
+        end
+
+        def pending_tool_name
+          @pending_tool_name
+        end
+
+        def pending_tool_args
+          @pending_tool_args
+        end
+
+        def tool_confirmation_response
+          @mutex.synchronize { @tool_confirmation_response }
+        end
+
+        def tool_confirmation_response=(value)
+          @mutex.synchronize do
+            @tool_confirmation_response = value
+            @tool_cv.signal
+          end
+        end
+
+        def request_tool_confirmation!(tool_name, tool_args, risk_label: "WRITE")
+          pending_text = format_tool_pending_text(tool_name, tool_args, risk_label)
+
+          @mutex.synchronize do
+            set_pending_tool(tool_name, tool_args)
+            append_tool_pending_message(pending_text)
+          end
+
+          scroll_to_bottom
+        end
+
+        def resolve_tool_confirmation!(decision)
+          @mutex.synchronize do
+            finalize_pending_message(decision)
+            reset_pending_tool
+            @message_generation += 1
+            @dirty = true
+          end
+        end
+
+        def clear_tool_confirmation!
+          @mutex.synchronize do
+            reset_pending_tool
+            @dirty = true
+          end
+        end
+
+        private
+
+        def format_tool_pending_text(tool_name, tool_args, risk_label)
+          args_text = tool_args.map { |k, v| "#{k}: #{v}" }.join(", ")
+          "[#{risk_label}] #{tool_name}(#{args_text}) — [y] approve / [n] reject / [a] approve all"
+        end
+
+        def finalize_pending_message(decision)
+          last_pending = @messages.reverse.find { |m| m[:role] == :tool_pending }
+          return unless last_pending
+
+          label = decision == :approved ? "approved" : "rejected"
+          last_pending[:role] = :tool_call
+          last_pending[:content] = last_pending[:content].sub(/ — \[y\].*/, " — #{label}")
+        end
+
+        def reset_pending_tool
+          @pending_tool_name = nil
+          @pending_tool_args = nil
+          @tool_confirmation_response = nil
+          @mode = :chat
+        end
+
+        def set_pending_tool(tool_name, tool_args)
+          @pending_tool_name = tool_name
+          @pending_tool_args = tool_args
+          @tool_confirmation_response = nil
+          @mode = :tool_confirmation
+        end
+
+        def append_tool_pending_message(pending_text)
+          @messages << {
+            role: :tool_pending,
+            content: String.new(pending_text),
+            timestamp: Time.now,
+            **Messages::ZERO_TOKEN_USAGE
+          }
+          @message_generation += 1
+          @dirty = true
+        end
+      end
+    end
+  end
+end