aia 0.9.12 → 0.9.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b10d493c773b5eecca9050d03180d8d5a23b07b2e79b0e737b284b6629f3319a
-  data.tar.gz: 10bef52c76f737db9e3d974f44690242b4c417a89e4c17808f243c281eb70817
+  metadata.gz: d5d9ca1e0f36d50857345bcad1268359e8435c16ba2c159d68482c070de59207
+  data.tar.gz: 20e10d41131b850e7320613f0959d8c94589e48422bc5ba948954c614c094c12
 SHA512:
-  metadata.gz: b10021b2557e63cfd4cbf19eead313c993af06e175ab81b1ab0f334afce4f6fc9ce9c877c2dd2f9e0da3093c07996daba667786f1200f8e2f7470b62161dcc64
-  data.tar.gz: de8952cc72bf776bae243d20fee31e60663f38f4d12a8a3497eb89002a63a2acf39ca4e67e97c344f9324106dc50b7d3c7e74e51154e74ccef238d909570316e
+  metadata.gz: bb7913215b44a686db90c9e9e4a69a00024611c0a28f7f06da4290ad7781ef9685288845ea17f3c4180f74badf4d0829a462596a0280aed91354b6d54a36f975
+  data.tar.gz: 1701b67da9e0aa8afa4cd1815422989544c191e50a38f58205984b1d96033d4a6dea27fe1b9efceb9307b231848fd9cc6440bd83203a9b03dfa7c5dbee700fd2

data/.envrc

@@ -1,2 +1,4 @@
+source_up
+
 export RR=`pwd`
 # PATH_add $RR/bin

data/.version

@@ -1 +1 @@
-0.9.12
+0.9.13

data/lib/aia/chat_processor_service.rb

@@ -28,11 +28,26 @@ module AIA
         result = send_to_client(prompt)
       end
 
-      unless result.is_a? String
-        result = result.content
+      # Preserve token information if available for metrics
+      if result.is_a?(String)
+        { content: result, metrics: nil }
+      elsif result.respond_to?(:multi_model?) && result.multi_model?
+        # Handle multi-model response with metrics
+        {
+          content: result.content,
+          metrics: nil,  # Individual model metrics handled separately
+          multi_metrics: result.metrics_list
+        }
+      else
+        {
+          content: result.content,
+          metrics: {
+            input_tokens: result.input_tokens,
+            output_tokens: result.output_tokens,
+            model_id: result.model_id
+          }
+        }
       end
-
-      result
     end
 
 

data/lib/aia/config/cli_parser.rb

@@ -250,6 +250,15 @@ module AIA
             config.completion = shell
           end
 
+          opts.on("--metrics", "Display token usage in chat mode") do
+            config.show_metrics = true
+          end
+
+          opts.on("--cost", "Include cost calculations with metrics (requires --metrics)") do
+            config.show_cost = true
+            config.show_metrics = true  # Automatically enable metrics when cost is requested
+          end
+
           opts.on("--version", "Show version") do
             puts AIA::VERSION
             exit

data/lib/aia/ruby_llm_adapter.rb

@@ -310,9 +310,15 @@ module AIA
       prompt_parts << ""
 
       results.each do |model_name, result|
-        next if result.to_s.start_with?("Error with")
+        # Extract content from RubyLLM::Message if needed
+        content = if result.respond_to?(:content)
+                    result.content
+                  else
+                    result.to_s
+                  end
+        next if content.start_with?("Error with")
         prompt_parts << "#{model_name}:"
-        prompt_parts << result.to_s
+        prompt_parts << content
         prompt_parts << ""
       end
 
@@ -321,13 +327,64 @@ module AIA
     end
 
     def format_individual_responses(results)
-      output = []
+      # For metrics support, return a special structure if all results have token info
+      has_metrics = results.values.all? { |r| r.respond_to?(:input_tokens) && r.respond_to?(:output_tokens) }
+      
+      if has_metrics && AIA.config.show_metrics
+        # Return structured data that preserves metrics for multi-model
+        format_multi_model_with_metrics(results)
+      else
+        # Original string formatting for non-metrics mode
+        output = []
+        results.each do |model_name, result|
+          output << "from: #{model_name}"
+          # Extract content from RubyLLM::Message if needed
+          content = if result.respond_to?(:content)
+                      result.content
+                    else
+                      result.to_s
+                    end
+          output << content
+          output << "" # Add blank line between results
+        end
+        output.join("\n")
+      end
+    end
+    
+    def format_multi_model_with_metrics(results)
+      # Create a composite response that includes all model responses and metrics
+      formatted_content = []
+      metrics_data = []
+      
       results.each do |model_name, result|
-        output << "from: #{model_name}"
-        output << result
-        output << "" # Add blank line between results
+        formatted_content << "from: #{model_name}"
+        formatted_content << result.content
+        formatted_content << ""
+        
+        # Collect metrics for each model
+        metrics_data << {
+          model_id: model_name,
+          input_tokens: result.input_tokens,
+          output_tokens: result.output_tokens
+        }
+      end
+      
+      # Return a special MultiModelResponse that ChatProcessorService can handle
+      MultiModelResponse.new(formatted_content.join("\n"), metrics_data)
+    end
+    
+    # Helper class to carry multi-model response with metrics
+    class MultiModelResponse
+      attr_reader :content, :metrics_list
+      
+      def initialize(content, metrics_list)
+        @content = content
+        @metrics_list = metrics_list
+      end
+      
+      def multi_model?
+        true
       end
-      output.join("\n")
     end
 
 
@@ -480,7 +537,8 @@ module AIA
                    chat_instance.ask(text_prompt, with: AIA.config.context_files)
                  end
 
-      response.content
+      # Return the full response object to preserve token information
+      response
     rescue StandardError => e
       e.message
     end

data/lib/aia/session.rb

@@ -372,11 +372,34 @@ module AIA
         conversation = @context_manager.get_context
 
         @ui_presenter.display_thinking_animation
-        response = @chat_processor.process_prompt(conversation)
+        response_data = @chat_processor.process_prompt(conversation)
+
+        # Handle new response format with metrics
+        if response_data.is_a?(Hash)
+          content = response_data[:content]
+          metrics = response_data[:metrics]
+          multi_metrics = response_data[:multi_metrics]
+        else
+          content = response_data
+          metrics = nil
+          multi_metrics = nil
+        end
 
-        @ui_presenter.display_ai_response(response)
-        @context_manager.add_to_context(role: "assistant", content: response)
-        @chat_processor.speak(response)
+        @ui_presenter.display_ai_response(content)
+        
+        # Display metrics if enabled and available (chat mode only)
+        if AIA.config.show_metrics
+          if multi_metrics
+            # Display metrics for each model in multi-model mode
+            @ui_presenter.display_multi_model_metrics(multi_metrics)
+          elsif metrics
+            # Display metrics for single model
+            @ui_presenter.display_token_metrics(metrics)
+          end
+        end
+        
+        @context_manager.add_to_context(role: "assistant", content: content)
+        @chat_processor.speak(content)
 
         @ui_presenter.display_separator
       end

data/lib/aia/ui_presenter.rb

@@ -117,5 +117,211 @@ module AIA
         yield
       end
     end
+
+    def display_token_metrics(metrics)
+      return unless metrics
+      
+      output_lines = []
+      output_lines << "═" * 55
+      output_lines << "Model: #{metrics[:model_id]}"
+      
+      if AIA.config.show_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
+      if AIA.config.out_file && !AIA.config.out_file.nil?
+        File.open(AIA.config.out_file, 'a') do |file|
+          output_lines.each { |line| file.puts line }
+        end
+      end
+    end
+    
+    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.show_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.show_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|
+        model_name = metrics[:model_id]
+        # Truncate model name if too long
+        model_name = model_name[0..17] + ".." if model_name.length > 19
+        
+        input_tokens = metrics[:input_tokens] || 0
+        output_tokens = metrics[:output_tokens] || 0
+        total_tokens = input_tokens + output_tokens
+        
+        if AIA.config.show_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.show_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
+      if AIA.config.out_file && !AIA.config.out_file.nil?
+        File.open(AIA.config.out_file, 'a') do |file|
+          output_lines.each { |line| file.puts line }
+        end
+      end
+    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
+    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
+    end
+    
+    def display_metrics_with_cost(metrics)
+      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)"
+      end
+    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)}"
+      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)"
+      end
+      
+      lines
+    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
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aia
 version: !ruby/object:Gem::Version
-  version: 0.9.12
+  version: 0.9.13
 platform: ruby
 authors:
 - Dewayne VanHoozer
@@ -71,14 +71,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.7
+        version: 0.5.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.7
+        version: 0.5.8
 - !ruby/object:Gem::Dependency
   name: ruby_llm
   requirement: !ruby/object:Gem::Requirement
@@ -177,20 +177,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: versionaire
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: word_wrapper
   requirement: !ruby/object:Gem::Requirement
@@ -329,7 +315,6 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- _notes.txt
 - bin/aia
 - docs/advanced-prompting.md
 - docs/assets/images/aia.png

data/_notes.txt

@@ -1,231 +0,0 @@
-
---- 2025-02-01 18:01:36 -0600
-    I have no idea where I left off in this branch. The objective is to replace all the back-end processes with AiClient.
-
-    Tests are failing.
-
-    Make a few changes.  It seems to be working in its basic modes.
-    
---- 2025-02-21 20:13:19 -0600
-    Implemented Stark's clean slate protocol
-
-  
-
-
-
---- 2025-03-29 21:39:46 -0500
-    starting the refactor to take advantage of the new capability of the PromptMananger gem.
-
-  lib/aia/chat_processor_service.rb
-
-
-
---- 2025-04-03 22:17:11 -0500
-    i have been tring to get multi-line input to work in the chat mode but have run into all kinds of problems. I think it would be best just to invoke the users editor for that kind of operation. Alo I am not sure but I thing the same ask method is used for getting values for parameters. changes may have been committed but they should be reversed back to the original and start over.
-
-  def get_multiline_input
-	  input_lines     = []
-	  current_line    = ""
-	  last_key_time   = Time.now
-	  waiting_printed = 0 # Track number of WAITING characters printed
-	
-	  STDIN.raw! # Enable raw mode for immediate keypress detection
-	  begin
-	    loop do
-	      begin
-	        r, _, _ = IO.select([STDIN], nil, nil, 0.1)
-	        if r
-	          char = STDIN.getc
-	          last_key_time = Time.now
-	          # Clear waiting characters when user types again
-	          if waiting_printed > 0
-	            print WAITING_ERASE * waiting_printed # Erase all waiting characters
-	            $stdout.flush
-	            waiting_printed = 0
-	          end
-	        else
-	          if (Time.now - last_key_time >= KEYPRESS_TIMEUT) &&
-	              waiting_printed == 0 &&
-	              (!input_lines.empty? || !current_line.empty?)
-	            print WAITING
-	            $stdout.flush
-	            waiting_printed = 1 # Record one '?' printed
-	          end
-	          next
-	        end
-	
-	      rescue Interrupt
-	        puts "\nInput cancelled. Discarding current input; please start over."
-	        input_lines     = []
-	        current_line    = ""
-	        waiting_printed = 0
-	        last_key_time   = Time.now
-	        next
-	      end
-	
-	      break if char.nil? # Handle EOF (Ctrl+D)
-	
-	      if char == "\r" || char == "\n"
-	        if current_line.empty? && !input_lines.empty?
-	          break # Two Enters in a row submits
-	        else
-	          input_lines << current_line
-	          current_line = ""
-	          waiting_printed = 0 # Reset waiting on new line
-	          print "\n\r"
-	          $stdout.flush
-	        end
-	
-	      elsif char == "\x04" # Ctrl+D
-	        break
-	
-	      elsif char == "\x08" || char == "\x7F" # Backspace or Delete
-	        if !current_line.empty?
-	          current_line.chop!
-	          print WAITING_ERASE
-	          $stdout.flush
-	        elsif waiting_printed > 0
-	          # Clear one waiting character if current_line is empty
-	          print "\b \b"
-	          $stdout.flush
-	          waiting_printed -= 1
-	        end
-	
-	      else
-	        current_line << char
-	        print char
-	        $stdout.flush
-	      end
-	    end
-	
-	  ensure
-	    STDIN.cooked! # Restore terminal to normal mode
-	  end
-	
-	  input_lines << current_line unless current_line.empty?
-	
-	  # Handle single-line special case
-	  if input_lines.size == 1
-	    if special_first_line_processing(input_lines.first)
-	      # If special (starts with "//"), return immediately as if double return was pressed
-	      return input_lines.first
-	    else
-	      # If not special, keep as is and return the full input
-	      return input_lines.join("\n")
-	    end
-	  end
-	
-	  input_lines.join("\n").tap do |result|
-	    puts "\n" if result.empty? # Clean up display if no input
-	  end
-	
-	rescue EOFError
-	  input_lines.join("\n")
-	end
-
-
-
---- 2025-04-03 22:18:18 -0500
-    by using subl -w for multi-line input in chat mode that gives us the ability to write ERB for chat input.
-
-  def get_multiline_input
-	  input_lines     = []
-	  current_line    = ""
-	  last_key_time   = Time.now
-	  waiting_printed = 0 # Track number of WAITING characters printed
-	
-	  STDIN.raw! # Enable raw mode for immediate keypress detection
-	  begin
-	    loop do
-	      begin
-	        r, _, _ = IO.select([STDIN], nil, nil, 0.1)
-	        if r
-	          char = STDIN.getc
-	          last_key_time = Time.now
-	          # Clear waiting characters when user types again
-	          if waiting_printed > 0
-	            print WAITING_ERASE * waiting_printed # Erase all waiting characters
-	            $stdout.flush
-	            waiting_printed = 0
-	          end
-	        else
-	          if (Time.now - last_key_time >= KEYPRESS_TIMEUT) &&
-	              waiting_printed == 0 &&
-	              (!input_lines.empty? || !current_line.empty?)
-	            print WAITING
-	            $stdout.flush
-	            waiting_printed = 1 # Record one '?' printed
-	          end
-	          next
-	        end
-	
-	      rescue Interrupt
-	        puts "\nInput cancelled. Discarding current input; please start over."
-	        input_lines     = []
-	        current_line    = ""
-	        waiting_printed = 0
-	        last_key_time   = Time.now
-	        next
-	      end
-	
-	      break if char.nil? # Handle EOF (Ctrl+D)
-	
-	      if char == "\r" || char == "\n"
-	        if current_line.empty? && !input_lines.empty?
-	          break # Two Enters in a row submits
-	        else
-	          input_lines << current_line
-	          current_line = ""
-	          waiting_printed = 0 # Reset waiting on new line
-	          print "\n\r"
-	          $stdout.flush
-	        end
-	
-	      elsif char == "\x04" # Ctrl+D
-	        break
-	
-	      elsif char == "\x08" || char == "\x7F" # Backspace or Delete
-	        if !current_line.empty?
-	          current_line.chop!
-	          print WAITING_ERASE
-	          $stdout.flush
-	        elsif waiting_printed > 0
-	          # Clear one waiting character if current_line is empty
-	          print "\b \b"
-	          $stdout.flush
-	          waiting_printed -= 1
-	        end
-	
-	      else
-	        current_line << char
-	        print char
-	        $stdout.flush
-	      end
-	    end
-	
-	  ensure
-	    STDIN.cooked! # Restore terminal to normal mode
-	  end
-	
-	  input_lines << current_line unless current_line.empty?
-	
-	  # Handle single-line special case
-	  if input_lines.size == 1
-	    if special_first_line_processing(input_lines.first)
-	      # If special (starts with "//"), return immediately as if double return was pressed
-	      return input_lines.first
-	    else
-	      # If not special, keep as is and return the full input
-	      return input_lines.join("\n")
-	    end
-	  end
-	
-	  input_lines.join("\n").tap do |result|
-	    puts "\n" if result.empty? # Clean up display if no input
-	  end
-	
-	rescue EOFError
-	  input_lines.join("\n")
-	end
-
-