aia 1.1.1 → 2.0.0.0.pre.beta2

data/lib/aia/ui_presenter.rb

@@ -1,12 +1,17 @@
 # lib/aia/ui_presenter.rb
 
 require 'tty-screen'
+require 'tty-spinner'
+require 'tty-table'
 require 'reline'
+require 'fileutils'
 
 module AIA
+  # :reek:TooManyMethods -- one small builder per table/report section keeps each display testable in isolation
   class UIPresenter
-    USER_PROMPT = "Follow up (cntl-D or 'exit' to end) #=> "
-
+    USER_PROMPT = "Follow up (cntl-D or 'exit' to end) #=> ".freeze
+    HISTORY_FILE = File.join(Dir.home, '.config', 'aia', 'chat_history')
+    MAX_HISTORY = 50
 
     def initialize
       @terminal_width = TTY::Screen.width
@@ -16,27 +21,20 @@ module AIA
       puts "#{'═' * @terminal_width}\n"
     end
 
-
     def display_ai_response(response)
       puts "\nAI: "
       format_chat_response(response)
-
-      out_file = AIA.config.output.file
-      if out_file && !out_file.nil?
-        File.open(out_file, 'a') do |file|
-          file.puts "\nAI: "
-          format_chat_response(response, file)
-        end
-      end
     end
 
-
+    # :reek:TooManyStatements -- line-by-line rendering with a code-fence state machine; the states share locals
     def format_chat_response(response, output = $stdout)
       indent = '   '
 
       # Convert RubyLLM::Message to string if necessary
-      response_text = if response.is_a?(RubyLLM::Message)
+      response_text = if defined?(RubyLLM::Message) && response.is_a?(RubyLLM::Message)
                         response.content.to_s
+                      elsif response.respond_to?(:reply)
+                        response.reply.to_s
                       elsif response.respond_to?(:to_s)
                         response.to_s
                       else
@@ -67,17 +65,14 @@ module AIA
       end
     end
 
-
     def display_separator
       puts "\n#{'─' * @terminal_width}"
     end
 
-
     def display_chat_end
       puts "\nChat session ended."
     end
 
-
     # This is the follow up question in a chat session
     def ask_question
       puts USER_PROMPT
@@ -85,24 +80,34 @@ module AIA
       begin
         input = Reline.readline('', true)
         return nil if input.nil? # Handle Ctrl+D
-        Reline::HISTORY << input unless input.strip.empty?
+        save_chat_history unless input.strip.empty?
         input
       rescue Interrupt
         puts "\nChat session interrupted."
-        return 'exit'
+        'exit'
       end
     end
 
+    # Load persistent chat history into Reline
+    def load_chat_history
+      Reline::HISTORY.clear
+      history_file = chat_history_file
+      return unless history_file && File.exist?(history_file)
+
+      lines = File.readlines(history_file, chomp: true).last(MAX_HISTORY)
+      lines.each { |line| Reline::HISTORY << line }
+    end
+
     def display_info(message)
-      puts "\n#{message}"
+      $stderr.puts "\n#{message}"
     end
 
     def display_error(message)
-      warn "ERROR: #{message}"
+      $stderr.puts "\n❌ ERROR: #{message}\n"
     end
 
     def display_warning(message)
-      warn "WARNING: #{message}"
+      $stderr.puts "\n⚠  WARNING: #{message}\n"
     end
 
     def with_spinner(message = "Processing", operation_type = nil)
@@ -118,213 +123,184 @@ module AIA
       result
     end
 
+    # :reek:TooManyStatements -- one metrics table with header/row/alignment variants for cost vs no-cost display
     def display_token_metrics(metrics)
       return unless metrics
-      
-      output_lines = []
-      output_lines << "═" * 55
-      output_lines << "Model: #{metrics[:model_id]}"
-      
+
+      model_id      = metrics[:model_id] || 'unknown'
+      input_tokens  = metrics[:input_tokens] || 0
+      output_tokens = metrics[:output_tokens] || 0
+      total_tokens  = input_tokens + output_tokens
+      time_str      = format_elapsed(metrics[:elapsed])
+
       if AIA.config.flags.cost
-        output_lines.concat(format_metrics_with_cost(metrics))
-      else
-        output_lines.concat(format_metrics_basic(metrics))
-      end
-      
-      output_lines << "═" * 55
-      
-      # Output to STDOUT
-      output_lines.each { |line| puts line }
-      
-      # Also write to file if configured
-      out_file = AIA.config.output.file
-      if out_file && !out_file.nil?
-        File.open(out_file, 'a') do |file|
-          output_lines.each { |line| file.puts line }
+        cost_data = calculate_cost(metrics)
+        if cost_data[:available]
+          header = %w[Model Input Output Total Cost x1000 Time]
+          row    = [
+            model_id,
+            input_tokens, output_tokens, total_tokens,
+            "$#{'%.5f' % cost_data[:total_cost]}",
+            "$#{'%.2f' % (cost_data[:total_cost] * 1000)}",
+            time_str
+          ]
+          alignments = %i[left right right right right right right]
+        else
+          header = %w[Model Input Output Total Cost Time]
+          row    = [model_id, input_tokens, output_tokens, total_tokens, "N/A", time_str]
+          alignments = %i[left right right right right right]
         end
+      else
+        header = %w[Model Input Output Total Time]
+        row    = [model_id, input_tokens, output_tokens, total_tokens, time_str]
+        alignments = %i[left right right right right]
       end
+
+      table = TTY::Table.new(header, [row])
+      rendered = table.render(:unicode, resize: true, alignments: alignments, padding: [0, 1])
+
+      puts rendered
+      write_to_output_file(rendered)
     end
 
+    # :reek:TooManyStatements -- table assembly: rows, totals, render, output; each piece delegated to a builder
     def display_multi_model_metrics(metrics_list)
       return unless metrics_list && !metrics_list.empty?
-      
-      output_lines = []
-      
-      # Determine table width based on whether costs are shown
-      if AIA.config.flags.cost
-        table_width = 80
-      else
-        table_width = 60
-      end
-      
-      output_lines << "═" * table_width
-      output_lines << "Multi-Model Token Usage"
-      output_lines << "─" * table_width
-      
-      # Build header row
-      if AIA.config.flags.cost
-        output_lines << sprintf("%-20s %10s %10s %10s %12s %10s", 
-                                "Model", "Input", "Output", "Total", "Cost", "x1000")
-        output_lines << "─" * table_width
-      else
-        output_lines << sprintf("%-20s %10s %10s %10s", 
-                                "Model", "Input", "Output", "Total")
-        output_lines << "─" * table_width
-      end
-      
-      # Process each model
-      total_input = 0
-      total_output = 0
-      total_cost = 0.0
-      
-      metrics_list.each do |metrics|
-        # Use display_name if available (includes role), otherwise fall back to model_id
-        model_name = metrics[:display_name] || metrics[:model_id]
-        # Truncate model name if too long
-        model_name = model_name[0..17] + ".." if model_name.to_s.length > 19
-
-        input_tokens = metrics[:input_tokens] || 0
-        output_tokens = metrics[:output_tokens] || 0
-        total_tokens = input_tokens + output_tokens
-        
-        if AIA.config.flags.cost
-          cost_data = calculate_cost(metrics)
-          if cost_data[:available]
-            cost_str = "$#{'%.5f' % cost_data[:total_cost]}"
-            x1000_str = "$#{'%.2f' % (cost_data[:total_cost] * 1000)}"
-            total_cost += cost_data[:total_cost]
-          else
-            cost_str = "N/A"
-            x1000_str = "N/A"
-          end
-          
-          output_lines << sprintf("%-20s %10d %10d %10d %12s %10s",
-                                  model_name, input_tokens, output_tokens, total_tokens, cost_str, x1000_str)
-        else
-          output_lines << sprintf("%-20s %10d %10d %10d",
-                                  model_name, input_tokens, output_tokens, total_tokens)
-        end
-        
-        total_input += input_tokens
-        total_output += output_tokens
-      end
-      
-      # Display totals row
-      output_lines << "─" * table_width
-      total_tokens = total_input + total_output
-      
-      if AIA.config.flags.cost && total_cost > 0
-        cost_str = "$#{'%.5f' % total_cost}"
-        x1000_str = "$#{'%.2f' % (total_cost * 1000)}"
-        output_lines << sprintf("%-20s %10d %10d %10d %12s %10s",
-                               "TOTAL", total_input, total_output, total_tokens, cost_str, x1000_str)
-      else
-        output_lines << sprintf("%-20s %10d %10d %10d",
-                               "TOTAL", total_input, total_output, total_tokens)
-      end
-      
-      output_lines << "═" * table_width
-      
-      # Output to STDOUT
-      output_lines.each { |line| puts line }
-      
-      # Also write to file if configured
-      out_file = AIA.config.output.file
-      if out_file && !out_file.nil?
-        File.open(out_file, 'a') do |file|
-          output_lines.each { |line| file.puts line }
-        end
-      end
+
+      show_cost       = AIA.config.flags.cost
+      show_similarity = metrics_list.any? { |m| m.key?(:similarity) }
+      totals          = MultiModelTotals.new(0, 0, 0.0, 0.0)
+
+      rows = metrics_list.map { |metrics| multi_model_row(metrics, totals, show_cost, show_similarity) }
+      rows << :separator
+      rows << multi_model_totals_row(totals, show_cost, show_similarity)
+
+      table = TTY::Table.new(multi_model_header(show_cost, show_similarity), rows)
+      rendered = table.render(:unicode, resize: true,
+                                        alignments: multi_model_alignments(show_cost, show_similarity),
+                                        padding: [0, 1])
+
+      puts "\nMulti-Model Token Usage"
+      puts rendered
+      write_to_output_file("Multi-Model Token Usage\n#{rendered}")
     end
 
     private
-    
-    def display_metrics_basic(metrics)
-      puts "Input tokens:  #{metrics[:input_tokens] || 'N/A'}"
-      puts "Output tokens: #{metrics[:output_tokens] || 'N/A'}"
-      
-      if metrics[:input_tokens] && metrics[:output_tokens]
-        total = metrics[:input_tokens] + metrics[:output_tokens]
-        puts "Total tokens:  #{total}"
-      end
+
+    # Running totals accumulated while building multi-model table rows.
+    MultiModelTotals = Struct.new(:input, :output, :cost, :max_elapsed)
+
+    def multi_model_header(show_cost, show_similarity)
+      header = %w[Model Input Output Total]
+      header += %w[Cost x1000] if show_cost
+      header << "Time"
+      header << "Sim" if show_similarity
+      header
     end
-    
-    def format_metrics_basic(metrics)
-      lines = []
-      lines << "Input tokens:  #{metrics[:input_tokens] || 'N/A'}"
-      lines << "Output tokens: #{metrics[:output_tokens] || 'N/A'}"
-      
-      if metrics[:input_tokens] && metrics[:output_tokens]
-        total = metrics[:input_tokens] + metrics[:output_tokens]
-        lines << "Total tokens:  #{total}"
-      end
-      
-      lines
+
+    def multi_model_row(metrics, totals, show_cost, show_similarity)
+      input_tokens  = metrics[:input_tokens] || 0
+      output_tokens = metrics[:output_tokens] || 0
+      elapsed       = metrics[:elapsed]
+
+      totals.input       += input_tokens
+      totals.output      += output_tokens
+      totals.max_elapsed  = [totals.max_elapsed, elapsed || 0].max
+
+      row = [(metrics[:model_id] || metrics[:display_name]).to_s,
+             input_tokens, output_tokens, input_tokens + output_tokens]
+      row += multi_model_cost_cells(metrics, totals) if show_cost
+      row << format_elapsed(elapsed)
+      row << format_similarity(metrics[:similarity]) if show_similarity
+      row
     end
-    
-    def display_metrics_with_cost(metrics)
+
+    # Cost cells for one row; adds to totals only when pricing is available.
+    def multi_model_cost_cells(metrics, totals)
       cost_data = calculate_cost(metrics)
-      
-      if cost_data[:available]
-        puts "Input tokens:  #{metrics[:input_tokens]} ($#{'%.5f' % cost_data[:input_cost]})"
-        puts "Output tokens: #{metrics[:output_tokens]} ($#{'%.5f' % cost_data[:output_cost]})"
-        puts "Total cost:    $#{'%.5f' % cost_data[:total_cost]}"
-        puts "Cost x1000:    $#{'%.2f' % (cost_data[:total_cost] * 1000)}"
-      else
-        puts "Input tokens:  #{metrics[:input_tokens] || 'N/A'}"
-        puts "Output tokens: #{metrics[:output_tokens] || 'N/A'}"
-        total = (metrics[:input_tokens] || 0) + (metrics[:output_tokens] || 0)
-        puts "Total tokens:  #{total}"
-        puts "Cost:          N/A (pricing not available)"
+      return %w[N/A N/A] unless cost_data[:available]
+
+      cost = cost_data[:total_cost]
+      totals.cost += cost
+      format_cost_cells(cost)
+    end
+
+    def format_cost_cells(cost)
+      ["$#{'%.5f' % cost}", "$#{'%.2f' % (cost * 1000)}"]
+    end
+
+    def multi_model_totals_row(totals, show_cost, show_similarity)
+      row = ["TOTAL", totals.input, totals.output, totals.input + totals.output]
+      row += totals.cost.positive? ? format_cost_cells(totals.cost) : ["", ""] if show_cost
+      row << format_elapsed(totals.max_elapsed)
+      row << "" if show_similarity
+      row
+    end
+
+    def multi_model_alignments(show_cost, show_similarity)
+      alignments = %i[left right right right]
+      alignments += %i[right right] if show_cost
+      alignments << :right
+      alignments << :right if show_similarity
+      alignments
+    end
+
+    def save_chat_history
+      history_file = chat_history_file
+      return unless history_file
+      dir = File.dirname(history_file)
+      FileUtils.mkdir_p(dir)
+
+      entries = Reline::HISTORY.to_a.last(MAX_HISTORY)
+      File.write(history_file, entries.join("\n") + "\n")
+    end
+
+    def chat_history_file
+      config = AIA.config
+      if config.respond_to?(:output) && config.output.respond_to?(:history_file)
+        hf = config.output.history_file
+        return nil if hf == false   # --no-history-file disables chat history
+        return File.expand_path(hf) if hf
+      end
+      paths = config.respond_to?(:paths) ? config.paths : nil
+      if paths.respond_to?(:aia_dir) && paths.aia_dir
+        return File.join(File.expand_path(paths.aia_dir), 'chat_history')
       end
+      HISTORY_FILE
     end
-    
-    def format_metrics_with_cost(metrics)
-      lines = []
-      cost_data = calculate_cost(metrics)
-      
-      if cost_data[:available]
-        lines << "Input tokens:  #{metrics[:input_tokens]} ($#{'%.5f' % cost_data[:input_cost]})"
-        lines << "Output tokens: #{metrics[:output_tokens]} ($#{'%.5f' % cost_data[:output_cost]})"
-        lines << "Total cost:    $#{'%.5f' % cost_data[:total_cost]}"
-        lines << "Cost x1000:    $#{'%.2f' % (cost_data[:total_cost] * 1000)}"
+
+    def format_similarity(score)
+      return "ref" if score.nil?
+      "%.1f%%" % (score * 100)
+    end
+
+    def format_elapsed(seconds)
+      return "" unless seconds
+
+      if seconds < 60
+        "%.1fs" % seconds
       else
-        lines << "Input tokens:  #{metrics[:input_tokens] || 'N/A'}"
-        lines << "Output tokens: #{metrics[:output_tokens] || 'N/A'}"
-        total = (metrics[:input_tokens] || 0) + (metrics[:output_tokens] || 0)
-        lines << "Total tokens:  #{total}"
-        lines << "Cost:          N/A (pricing not available)"
+        minutes = (seconds / 60).to_i
+        secs = seconds % 60
+        "#{minutes}m %04.1fs" % secs
       end
-      
-      lines
     end
-    
+
+    def write_to_output_file(text)
+      out_file = AIA.config.output.file
+      return unless out_file
+
+      File.open(out_file, 'a') { |f| f.puts text }
+    end
+
     def calculate_cost(metrics)
       return { available: false } unless metrics[:model_id] && metrics[:input_tokens] && metrics[:output_tokens]
-      
-      # Look up model info from RubyLLM
-      begin
-        model_info = RubyLLM::Models.find(metrics[:model_id])
-        return { available: false } unless model_info
-        
-        input_price = model_info.input_price_per_million
-        output_price = model_info.output_price_per_million
-        
-        return { available: false } unless input_price && output_price
-        
-        input_cost = metrics[:input_tokens] * input_price / 1_000_000.0
-        output_cost = metrics[:output_tokens] * output_price / 1_000_000.0
-        total_cost = input_cost + output_cost
-        
-        {
-          available: true,
-          input_cost: input_cost,
-          output_cost: output_cost,
-          total_cost: total_cost
-        }
-      rescue StandardError => e
-        { available: false, error: e.message }
-      end
+
+      CostCalculator.calculate(
+        model_id:      metrics[:model_id],
+        input_tokens:  metrics[:input_tokens],
+        output_tokens: metrics[:output_tokens]
+      )
     end
   end
 end