aia 0.9.23 → 0.10.2

data/lib/aia/session.rb

@@ -9,7 +9,6 @@ require "fileutils"
 require "amazing_print"
 require_relative "directive_processor"
 require_relative "history_manager"
-require_relative "context_manager"
 require_relative "ui_presenter"
 require_relative "chat_processor_service"
 require_relative "prompt_handler"
@@ -45,36 +44,18 @@ module AIA
     end
 
     def initialize_components
-      # For multi-model: create separate context manager per model (ADR-002 revised + ADR-005)
-      # For single-model: maintain backward compatibility with single context manager
-      if AIA.config.model.is_a?(Array) && AIA.config.model.size > 1
-        @context_managers = {}
-        AIA.config.model.each do |model_spec|
-          # Handle both old string format and new hash format (ADR-005)
-          internal_id = if model_spec.is_a?(Hash)
-                          model_spec[:internal_id]
-                        else
-                          model_spec
-                        end
-
-          @context_managers[internal_id] = ContextManager.new(
-            system_prompt: AIA.config.system_prompt
-          )
-        end
-        @context_manager = nil # Signal we're using per-model managers
-      else
-        @context_manager = ContextManager.new(system_prompt: AIA.config.system_prompt)
-        @context_managers = nil
-      end
-
+      # RubyLLM's Chat instances maintain conversation history internally
+      # via @messages array. No separate context manager needed.
+      # Checkpoint/restore directives access Chat.@messages directly via AIA.client.chats
       @ui_presenter = UIPresenter.new
       @directive_processor = DirectiveProcessor.new
       @chat_processor = ChatProcessorService.new(@ui_presenter, @directive_processor)
     end
 
     def setup_output_file
-      if AIA.config.out_file && !AIA.config.out_file.nil? && !AIA.append? && File.exist?(AIA.config.out_file)
-        File.open(AIA.config.out_file, "w") { } # Truncate the file
+      out_file = AIA.config.output.file
+      if out_file && !out_file.nil? && !AIA.append? && File.exist?(out_file)
+        File.open(out_file, "w") { } # Truncate the file
       end
     end
 
@@ -137,7 +118,7 @@ module AIA
     end
 
     def setup_prompt_processing(prompt_id)
-      role_id = AIA.config.role
+      role_id = AIA.config.prompts.role
 
       begin
         prompt = @prompt_handler.get_prompt(prompt_id, role_id)
@@ -225,23 +206,21 @@ module AIA
     end
 
     # Send prompt to AI and handle the response
+    # RubyLLM's Chat automatically adds user messages and responses to its internal @messages
     def send_prompt_and_get_response(prompt_text)
-      # Add prompt to conversation context
-      @context_manager.add_to_context(role: "user", content: prompt_text)
-
-      # Process the prompt
+      # Process the prompt - RubyLLM Chat maintains conversation history internally
       @ui_presenter.display_thinking_animation
-      response = @chat_processor.process_prompt(@context_manager.get_context)
+      response_data = @chat_processor.process_prompt(prompt_text)
 
-      # Add AI response to context
-      @context_manager.add_to_context(role: "assistant", content: response)
+      # Handle response format (may include metrics)
+      content = response_data.is_a?(Hash) ? response_data[:content] : response_data
 
       # Output the response
-      @chat_processor.output_response(response)
+      @chat_processor.output_response(content)
 
       # Process any directives in the response
-      if @directive_processor.directive?(response)
-        directive_result = @directive_processor.process(response, @context_manager)
+      if @directive_processor.directive?(content)
+        directive_result = @directive_processor.process(content, nil)
         puts "\nDirective output: #{directive_result}" if directive_result && !directive_result.strip.empty?
       end
     end
@@ -315,19 +294,16 @@ module AIA
 
       return if context.empty?
 
-      # Add context files content to context
-      @context_manager.add_to_context(role: "user", content: context)
-
-      # Process the context
+      # Process the context - RubyLLM Chat maintains conversation history internally
       @ui_presenter.display_thinking_animation
-      response = @chat_processor.process_prompt(@context_manager.get_context)
+      response_data = @chat_processor.process_prompt(context)
 
-      # Add AI response to context
-      @context_manager.add_to_context(role: "assistant", content: response)
+      # Handle response format (may include metrics)
+      content = response_data.is_a?(Hash) ? response_data[:content] : response_data
 
       # Output the response
-      @chat_processor.output_response(response)
-      @chat_processor.speak(response)
+      @chat_processor.output_response(content)
+      @chat_processor.speak(content)
       @ui_presenter.display_separator
     end
 
@@ -347,14 +323,15 @@ module AIA
         @chat_prompt.text = piped_input
         processed_input = @chat_prompt.to_s
 
-        @context_manager.add_to_context(role: "user", content: processed_input)
-
+        # Process the piped input - RubyLLM Chat maintains conversation history internally
         @ui_presenter.display_thinking_animation
-        response = @chat_processor.process_prompt(@context_manager.get_context)
+        response_data = @chat_processor.process_prompt(processed_input)
+
+        # Handle response format (may include metrics)
+        content = response_data.is_a?(Hash) ? response_data[:content] : response_data
 
-        @context_manager.add_to_context(role: "assistant", content: response)
-        @chat_processor.output_response(response)
-        @chat_processor.speak(response) if AIA.speak?
+        @chat_processor.output_response(content)
+        @chat_processor.speak(content) if AIA.speak?
         @ui_presenter.display_separator
 
         STDIN.reopen(original_stdin)
@@ -375,8 +352,8 @@ module AIA
 
         break if follow_up_prompt.nil? || follow_up_prompt.strip.downcase == "exit" || follow_up_prompt.strip.empty?
 
-        if AIA.config.out_file
-          File.open(AIA.config.out_file, "a") do |file|
+        if AIA.config.output.file
+          File.open(AIA.config.output.file, "a") do |file|
             file.puts "\nYou: #{follow_up_prompt}"
           end
         end
@@ -389,29 +366,10 @@ module AIA
         @chat_prompt.text = follow_up_prompt
         processed_prompt = @chat_prompt.to_s
 
-        # Handle per-model contexts (ADR-002 revised)
-        if @context_managers
-          # Multi-model: add user prompt to each model's context
-          @context_managers.each_value do |ctx_mgr|
-            ctx_mgr.add_to_context(role: "user", content: processed_prompt)
-          end
-
-          # Get per-model conversations
-          conversations = {}
-          @context_managers.each do |model_name, ctx_mgr|
-            conversations[model_name] = ctx_mgr.get_context
-          end
-
-          @ui_presenter.display_thinking_animation
-          response_data = @chat_processor.process_prompt(conversations)
-        else
-          # Single-model: use original logic
-          @context_manager.add_to_context(role: "user", content: processed_prompt)
-          conversation = @context_manager.get_context
-
-          @ui_presenter.display_thinking_animation
-          response_data = @chat_processor.process_prompt(conversation)
-        end
+        # Process the prompt - RubyLLM Chat maintains conversation history internally
+        # via @messages array. Each model's Chat instance tracks its own conversation.
+        @ui_presenter.display_thinking_animation
+        response_data = @chat_processor.process_prompt(processed_prompt)
 
         # Handle new response format with metrics
         if response_data.is_a?(Hash)
@@ -426,8 +384,8 @@ module AIA
 
         @ui_presenter.display_ai_response(content)
 
-        # Display metrics if enabled and available (chat mode only)
-        if AIA.config.show_metrics
+        # Display token usage if enabled and available (chat mode only)
+        if AIA.config.flags.tokens
           if multi_metrics
             # Display metrics for each model in multi-model mode
             @ui_presenter.display_multi_model_metrics(multi_metrics)
@@ -437,21 +395,6 @@ module AIA
           end
         end
 
-        # Add responses to context (ADR-002 revised)
-        if @context_managers
-          # Multi-model: parse combined response and add each model's response to its own context
-          parsed_responses = parse_multi_model_response(content)
-          parsed_responses.each do |model_name, model_response|
-            @context_managers[model_name]&.add_to_context(
-              role: "assistant",
-              content: model_response
-            )
-          end
-        else
-          # Single-model: add response to single context
-          @context_manager.add_to_context(role: "assistant", content: content)
-        end
-
         @chat_processor.speak(content)
 
         @ui_presenter.display_separator
@@ -459,71 +402,21 @@ module AIA
     end
 
     def process_chat_directive(follow_up_prompt)
-      # For multi-model, use first context manager for directives (ADR-002 revised)
-      # TODO: Consider if directives should affect all contexts or just one
-      context_for_directive = @context_managers ? @context_managers.values.first : @context_manager
-      directive_output = @directive_processor.process(follow_up_prompt, context_for_directive)
-
-      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
-
-    def handle_clear_directive
-      # Clear context manager(s) - ADR-002 revised
-      if @context_managers
-        # Multi-model: clear all context managers
-        @context_managers.each_value { |ctx_mgr| ctx_mgr.clear_context(keep_system_prompt: true) }
-      else
-        # Single-model: clear single context manager
-        @context_manager.clear_context(keep_system_prompt: true)
-      end
-
-      # Try clearing the client's context
-      if AIA.config.client && AIA.config.client.respond_to?(:clear_context)
-        begin
-          AIA.config.client.clear_context
-        rescue => e
-          STDERR.puts "Warning: Error clearing client context: #{e.message}"
-          # Continue anyway - the context manager has been cleared which is the main goal
-        end
+      # Directives now access RubyLLM's Chat.@messages directly via AIA.client
+      # The second parameter is no longer used by checkpoint/restore/clear/review
+      directive_output = @directive_processor.process(follow_up_prompt, nil)
+
+      # Checkpoint-related directives (clear, checkpoint, restore, review) handle
+      # everything internally via the Checkpoint module, which operates directly
+      # on RubyLLM's Chat.@messages - no additional handling needed here.
+      if follow_up_prompt.strip.start_with?("//clear", "//checkpoint", "//restore", "//review", "//context")
+        @ui_presenter.display_info(directive_output) unless directive_output.nil? || directive_output.strip.empty?
+        return nil
       end
 
-      # Note: We intentionally do NOT reinitialize the client here
-      # as that could cause termination if model initialization fails
-
-      @ui_presenter.display_info("Chat context cleared.")
-      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 - ADR-002 revised
-      if directive_output.start_with?("Context restored")
-        # Clear the client's context without reinitializing the entire adapter
-        if AIA.config.client && AIA.config.client.respond_to?(:clear_context)
-          begin
-            AIA.config.client.clear_context
-          rescue => e
-            STDERR.puts "Warning: Error clearing client context after restore: #{e.message}"
-            # Continue anyway - the context manager has been restored which is the main goal
-          end
-        end
-
-        # Note: For multi-model, only the first context manager was used for restore
-        # This is a limitation of the current directive system
-        # TODO: Consider supporting restore for all context managers
-      end
+      return handle_empty_directive_output if directive_output.nil? || directive_output.strip.empty?
 
-      @ui_presenter.display_info(directive_output)
-      nil
+      handle_successful_directive(follow_up_prompt, directive_output)
     end
 
     def handle_empty_directive_output
@@ -579,7 +472,7 @@ module AIA
 
     def cleanup_chat_prompt
       if @chat_prompt_id
-        puts "[DEBUG] Cleaning up chat prompt: #{@chat_prompt_id}" if AIA.debug?
+        logger.debug("Cleaning up chat prompt", chat_prompt_id: @chat_prompt_id)
         begin
           @chat_prompt.delete
           @chat_prompt_id = nil # Prevent repeated attempts if error occurs elsewhere

data/lib/aia/topic_context.rb

@@ -0,0 +1,125 @@
+# lib/aia/topic_context.rb
+# Just thinking about the problem ...
+# maybe a directive like //topic [topic]
+# sets manually (when present) or dynamically when not present
+# and //topics - will list current topics
+# thinking about the //checkpoint and //restore directives
+#
+module AIA
+  class TopicContext
+    attr_reader :context_size
+
+    # Initialize topic context manager
+    # @param context_size [Integer] max allowed bytes per topic
+    def initialize(context_size = 128_000)
+      @storage = Hash.new { |h, k| h[k] = [] } # auto-initialize empty array
+      @context_size = context_size
+      @total_chars = 0
+      @mutex = Mutex.new # ensure thread safety
+    end
+
+    # Store a request/response pair under the given topic (or auto-generate one)
+    # @param request [String]
+    # @param response [String]
+    # @param topic [String, nil]
+    # @return [String] topic name used
+    def store_conversation(request, response, topic = nil)
+      raise ArgumentError, "request and response must be strings" unless request.is_a?(String) && response.is_a?(String)
+
+      topic ||= generate_topic(request)
+      size = request.bytesize + response.bytesize
+
+      @mutex.synchronize do
+        # Add the new context
+        @storage[topic] << { request:, response:, size:, time: Time.now }
+
+        # Update the global total
+        @total_chars += size
+
+        # Trim old entries if we exceeded the per-topic limit
+        trim_topic(topic)
+      end
+
+      topic
+    end
+
+    # Return an array of contexts for the given topic
+    # @param topic [String]
+    # @return [Array<Hash>]
+    def get_conversation(topic)
+      @mutex.synchronize { @storage[topic] || [] }
+    end
+
+    # All topic names
+    # @return [Array<String>]
+    def topics
+      @mutex.synchronize { @storage.keys }
+    end
+
+    # Hash of topic => array_of_contexts
+    # @return [Hash<String, Array<Hash>>]
+    def all_conversations
+      @mutex.synchronize { @storage.dup }
+    end
+
+    # Total number of characters stored across all topics
+    # @return [Integer]
+    def total_chars
+      @mutex.synchronize { @total_chars }
+    end
+
+    # Empty the storage and reset counters
+    def clear
+      @mutex.synchronize do
+        @storage.clear
+        @total_chars = 0
+      end
+    end
+
+    # Get memory usage statistics for a topic
+    # @param topic [String]
+    # @return [Hash{Symbol => Integer}]
+    def topic_stats(topic)
+      @mutex.synchronize do
+        return {} unless @storage.key?(topic)
+
+        {
+          count: @storage[topic].length,
+          size: topic_total_size(topic),
+          avg_size: topic_total_size(topic).fdiv(@storage[topic].length),
+        }
+      end
+    end
+
+    private
+
+    # Topic extractor with better heuristic - uses first meaningful 3 words
+    # @param request [String]
+    # @return [String]
+    def generate_topic(request)
+      cleaned = request.downcase.gsub(/[^a-z0-9\s]/, "")
+      words = cleaned.split
+      return "general" if words.empty?
+
+      words.first(3).join("_")
+    end
+
+    # Remove oldest contexts from the topic until size <= @context_size
+    # @param topic [String]
+    def trim_topic(topic)
+      return unless @storage.key?(topic) && @storage[topic].size > 1
+
+      while topic_total_size(topic) > @context_size
+        removed = @storage[topic].shift # oldest context
+        @total_chars -= removed[:size]  # adjust global counter
+      end
+    end
+
+    # Helper to compute the sum of sizes for a topic
+    # @param topic [String]
+    # @return [Integer]
+    def topic_total_size(topic)
+      @storage[topic].sum { |ctx| ctx[:size] }
+    end
+  end
+end

data/lib/aia/ui_presenter.rb

@@ -26,8 +26,9 @@ module AIA
       puts "\nAI: "
       format_chat_response(response)
 
-      if AIA.config.out_file && !AIA.config.out_file.nil?
-        File.open(AIA.config.out_file, 'a') do |file|
+      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
@@ -125,7 +126,7 @@ module AIA
       output_lines << "═" * 55
       output_lines << "Model: #{metrics[:model_id]}"
       
-      if AIA.config.show_cost
+      if AIA.config.flags.cost
         output_lines.concat(format_metrics_with_cost(metrics))
       else
         output_lines.concat(format_metrics_basic(metrics))
@@ -137,20 +138,21 @@ module AIA
       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|
+      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
     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
+      if AIA.config.flags.cost
         table_width = 80
       else
         table_width = 60
@@ -161,7 +163,7 @@ module AIA
       output_lines << "─" * table_width
       
       # Build header row
-      if AIA.config.show_cost
+      if AIA.config.flags.cost
         output_lines << sprintf("%-20s %10s %10s %10s %12s %10s", 
                                 "Model", "Input", "Output", "Total", "Cost", "x1000")
         output_lines << "─" * table_width
@@ -177,15 +179,16 @@ module AIA
       total_cost = 0.0
       
       metrics_list.each do |metrics|
-        model_name = metrics[:model_id]
+        # 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.length > 19
-        
+        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.show_cost
+        if AIA.config.flags.cost
           cost_data = calculate_cost(metrics)
           if cost_data[:available]
             cost_str = "$#{'%.5f' % cost_data[:total_cost]}"
@@ -211,7 +214,7 @@ module AIA
       output_lines << "─" * table_width
       total_tokens = total_input + total_output
       
-      if AIA.config.show_cost && total_cost > 0
+      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",
@@ -227,13 +230,14 @@ module AIA
       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|
+      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
     end
-    
+
     private
     
     def display_metrics_basic(metrics)

data/lib/aia/utility.rb

@@ -10,22 +10,49 @@ module AIA
       end
 
       def user_tools?
-        AIA.config&.tool_paths && !AIA.config.tool_paths.empty?
+        AIA.config&.tools&.paths && !AIA.config.tools.paths.empty?
       end
 
       def mcp_servers?
         AIA.config&.mcp_servers && !AIA.config.mcp_servers.empty?
       end
 
+      # Returns only successfully connected MCP server names
       def mcp_server_names
+        # Use connected_mcp_servers if available (populated during MCP setup)
+        connected = AIA.config&.connected_mcp_servers
+        return connected if connected && !connected.empty?
+
+        # Fallback to configured servers if connection status not yet known
         return [] unless mcp_servers?
         AIA.config.mcp_servers.map { |s| s[:name] || s["name"] }.compact
       end
 
+      # Returns true if there are any connected MCP servers
+      def connected_mcp_servers?
+        connected = AIA.config&.connected_mcp_servers
+        connected && !connected.empty?
+      end
+
+      # Returns list of failed MCP servers with their errors
+      def failed_mcp_servers
+        AIA.config&.failed_mcp_servers || []
+      end
+
       def supports_tools?
-        AIA.config&.client&.model&.supports_functions? || false
+        AIA.client&.model&.supports_functions? || false
       end
 
+      # Returns the last refresh date from models.json modification time
+      def models_last_refresh
+        aia_dir = AIA.config&.paths&.aia_dir
+        return nil if aia_dir.nil?
+
+        models_file = File.join(File.expand_path(aia_dir), 'models.json')
+        return nil unless File.exist?(models_file)
+
+        File.mtime(models_file).strftime('%Y-%m-%d %H:%M')
+      end
 
       # Displays the AIA robot ASCII art
       # Yes, its slightly frivolous but it does contain some
@@ -37,40 +64,45 @@ module AIA
 
         mcp_version = defined?(RubyLLM::MCP::VERSION) ? " MCP v" + RubyLLM::MCP::VERSION : ''
 
-        # Extract model names from config (handles hash format from ADR-005)
-        model_display = if AIA.config&.model
-          models = AIA.config.model
-          if models.is_a?(String)
-            models
-          elsif models.is_a?(Array)
-            if models.first.is_a?(Hash)
-              models.map { |spec| spec[:model] }.join(', ')
+        # Extract model names from config (handles ModelSpec objects or Hashes)
+        model_display = if AIA.config&.models && !AIA.config.models.empty?
+          models = AIA.config.models
+          models.map do |spec|
+            if spec.is_a?(AIA::ModelSpec)
+              spec.name
+            elsif spec.is_a?(Hash)
+              spec[:name] || spec['name'] || spec.to_s
             else
-              models.join(', ')
+              spec.to_s
             end
-          else
-            models.to_s
-          end
+          end.join(', ')
         else
           'unknown-model'
         end
 
-        mcp_line = mcp_servers? ? "MCP: #{mcp_server_names.join(', ')}" : ''
+        # Build MCP line based on connection status
+        mcp_line = if !mcp_servers?
+          ''  # No MCP servers configured
+        elsif connected_mcp_servers?
+          "MCP: #{mcp_server_names.join(', ')}"
+        else
+          "MCP: (none connected)"
+        end
 
         puts <<-ROBOT
 
        ,      ,
        (\\____/) AI Assistant (v#{AIA::VERSION}) is Online
         (_oo_)   #{model_display}#{supports_tools? ? ' (supports tools)' : ''}
-         (O)       using #{AIA.config&.adapter || 'unknown-adapter'} (v#{RubyLLM::VERSION}#{mcp_version})
+         (O)       using #{AIA.config&.llm&.adapter || 'unknown-adapter'} (v#{RubyLLM::VERSION}#{mcp_version})
        __||__    \\) model db was last refreshed on
-     [/______\\]  /    #{AIA.config&.last_refresh || 'unknown'}
+     [/______\\]  /    #{models_last_refresh || 'unknown'}
     / \\__AI__/ \\/      #{user_tools? ? 'I will also use your tools' : (tools? ? 'You can share my tools' : 'I did not bring any tools')}
    /    /__\\              #{mcp_line}
   (\\   /____\\   #{user_tools? && tools? ? 'My Toolbox contains:' : ''}
         ROBOT
         if user_tools? && tools?
-          tool_names = AIA.config.respond_to?(:tool_names) ? AIA.config.tool_names : AIA.config.tools
+          tool_names = AIA.config.tool_names
           if tool_names && !tool_names.to_s.empty?
             puts WordWrapper::MinimumRaggedness.new(
                 width,