aia 0.9.12 → 0.9.14

data/lib/aia/directives/models.rb

@@ -85,30 +85,163 @@ module AIA
           puts "===================="
           puts
 
-          directives = self.methods(false).map(&:to_s).reject do |m|
-            ['run', 'initialize', 'private?', 'descriptions', 'aliases', 'build_aliases'].include?(m)
-          end.sort
-
-          build_aliases(directives)
+          # Manual descriptions for all directives
+          directive_descriptions = {
+            # Configuration directives
+            'config' => 'View or set configuration values',
+            'model' => 'View or change the AI model',
+            'temperature' => 'Set the temperature parameter for AI responses',
+            'top_p' => 'Set the top_p parameter for AI responses',
+            'clear' => 'Clear the conversation context',
+            'review' => 'Display the current conversation context with checkpoint markers',
+            'checkpoint' => 'Create a named checkpoint of the current context',
+            'restore' => 'Restore context to a previous checkpoint',
+
+            # Utility directives
+            'tools' => 'List available tools',
+            'next' => 'Set the next prompt in the sequence',
+            'pipeline' => 'Set or view the prompt workflow sequence',
+            'terse' => 'Add instruction for concise responses',
+            'robot' => 'Display ASCII robot art',
+
+            # Execution directives
+            'ruby' => 'Execute Ruby code',
+            'shell' => 'Execute shell commands',
+            'say' => 'Use text-to-speech to speak the text',
+
+            # Web and File directives
+            'webpage' => 'Fetch and include content from a webpage',
+            'include' => 'Include content from a file',
+            'include_file' => 'Include file content (internal use)',
+            'included_files' => 'List files that have been included',
+            'included_files=' => 'Set the list of included files',
+
+            # Model directives
+            'available_models' => 'List all available AI models',
+            'compare' => 'Compare responses from multiple models',
+            'help' => 'Show this help message',
+
+            # Aliases (these get their descriptions from main directive)
+            'cfg' => nil,  # alias for config
+            'temp' => nil, # alias for temperature
+            'topp' => nil, # alias for top_p
+            'context' => nil, # alias for review
+            'cp' => nil, # alias for checkpoint
+            'workflow' => nil, # alias for pipeline
+            'rb' => nil, # alias for ruby
+            'sh' => nil, # alias for shell
+            'web' => nil, # alias for webpage
+            'website' => nil, # alias for webpage
+            'import' => nil, # alias for include
+            'models' => nil, # alias for available_models
+            'all_models' => nil, # alias for available_models
+            'am' => nil, # alias for available_models
+            'llms' => nil, # alias for available_models
+            'available' => nil, # alias for available_models
+            'cmp' => nil, # alias for compare
+          }
+
+          # Get all registered directive modules from the Registry
+          all_modules = [
+            AIA::Directives::WebAndFile,
+            AIA::Directives::Utility,
+            AIA::Directives::Configuration,
+            AIA::Directives::Execution,
+            AIA::Directives::Models
+          ]
+
+          all_directives = {}
+          excluded_methods = ['run', 'initialize', 'private?', 'descriptions', 'aliases', 'build_aliases',
+                             'desc', 'method_added', 'register_directive_module', 'process',
+                             'directive?', 'prefix_size']
+
+          # Collect directives from all modules
+          all_modules.each do |mod|
+            methods = mod.methods(false).map(&:to_s).reject { |m| excluded_methods.include?(m) }
+
+            methods.each do |method|
+              # Skip if this is an alias (has nil description)
+              next if directive_descriptions.key?(method) && directive_descriptions[method].nil?
+
+              description = directive_descriptions[method] || method.gsub('_', ' ').capitalize
+
+              all_directives[method] = {
+                module: mod.name.split('::').last,
+                description: description,
+                aliases: []
+              }
+            end
+          end
 
-          directives.each do |directive|
-            next unless descriptions[directive]
+          # Manually map known aliases
+          alias_mappings = {
+            'config' => ['cfg'],
+            'temperature' => ['temp'],
+            'top_p' => ['topp'],
+            'review' => ['context'],
+            'checkpoint' => ['cp'],
+            'pipeline' => ['workflow'],
+            'ruby' => ['rb'],
+            'shell' => ['sh'],
+            'webpage' => ['web', 'website'],
+            'include' => ['import'],
+            'available_models' => ['models', 'all_models', 'am', 'llms', 'available'],
+            'compare' => ['cmp']
+          }
+
+          # Apply alias mappings
+          alias_mappings.each do |directive, aliases|
+            if all_directives[directive]
+              all_directives[directive][:aliases] = aliases
+            end
+          end
 
-            others = aliases[directive]
+          # Sort and display directives by category
+          categories = {
+            'Configuration' => ['config', 'model', 'temperature', 'top_p', 'clear', 'review', 'checkpoint', 'restore'],
+            'Utility' => ['tools', 'next', 'pipeline', 'terse', 'robot', 'help'],
+            'Execution' => ['ruby', 'shell', 'say'],
+            'Web & Files' => ['webpage', 'include'],
+            'Models' => ['available_models', 'compare']
+          }
+
+          categories.each do |category, directives|
+            puts "#{category}:"
+            puts "-" * category.length
+
+            directives.each do |directive|
+              info = all_directives[directive]
+              next unless info
+
+              if info[:aliases] && !info[:aliases].empty?
+                with_prefix = info[:aliases].map { |m| PromptManager::Prompt::DIRECTIVE_SIGNAL + m }
+                alias_text = " (aliases: #{with_prefix.join(', ')})"
+              else
+                alias_text = ""
+              end
 
-            if others.empty?
-              others_line = ""
-            else
-              with_prefix = others.map { |m| PromptManager::Prompt::DIRECTIVE_SIGNAL + m }
-              others_line = "\tAliases:#{with_prefix.join('  ')}\n"
+              puts "  //#{directive}#{alias_text}"
+              puts "      #{info[:description]}"
+              puts
             end
+          end
 
-            puts <<~TEXT
-              //#{directive} #{descriptions[directive]}
-              #{others_line}
-            TEXT
+          # Show any uncategorized directives
+          categorized = categories.values.flatten
+          uncategorized = all_directives.keys - categorized - ['include_file', 'included_files', 'included_files=']
+
+          if uncategorized.any?
+            puts "Other:"
+            puts "------"
+            uncategorized.sort.each do |directive|
+              info = all_directives[directive]
+              puts "  //#{directive}"
+              puts "      #{info[:description]}"
+              puts
+            end
           end
 
+          puts "\nTotal: #{all_directives.size} directives available"
           ""
         end
 

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
@@ -384,10 +407,12 @@ module AIA
 
     def process_chat_directive(follow_up_prompt)
       directive_output = @directive_processor.process(follow_up_prompt, @context_manager)
-      
+
       return handle_clear_directive if follow_up_prompt.strip.start_with?("//clear")
+      return handle_checkpoint_directive(directive_output) if follow_up_prompt.strip.start_with?("//checkpoint")
+      return handle_restore_directive(directive_output) if follow_up_prompt.strip.start_with?("//restore")
       return handle_empty_directive_output if directive_output.nil? || directive_output.strip.empty?
-      
+
       handle_successful_directive(follow_up_prompt, directive_output)
     end
 
@@ -415,6 +440,31 @@ module AIA
       nil
     end
 
+    def handle_checkpoint_directive(directive_output)
+      @ui_presenter.display_info(directive_output)
+      nil
+    end
+
+    def handle_restore_directive(directive_output)
+      # If the restore was successful, we also need to refresh the client's context
+      if directive_output.start_with?("Context restored")
+        # Try to clear and rebuild the client's context
+        if AIA.config.client && AIA.config.client.respond_to?(:clear_context)
+          AIA.config.client.clear_context
+        end
+
+        # Optionally reinitialize the client for a clean state
+        begin
+          AIA.config.client = AIA::RubyLLMAdapter.new
+        rescue => e
+          STDERR.puts "Error reinitializing client after restore: #{e.message}"
+        end
+      end
+
+      @ui_presenter.display_info(directive_output)
+      nil
+    end
+
     def handle_empty_directive_output
       nil
     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.14
 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
@@ -448,7 +433,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.1
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Multi-model AI CLI with dynamic prompts, consensus responses, shell & Ruby
   integration, and seamless chat workflows.