aia 0.9.22 → 0.9.24

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,28 +44,9 @@ 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)
@@ -225,23 +205,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 +293,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 +322,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)
@@ -389,29 +365,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)
@@ -437,21 +394,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 +401,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

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/utility.rb

@@ -13,6 +13,15 @@ module AIA
         AIA.config&.tool_paths && !AIA.config.tool_paths.empty?
       end
 
+      def mcp_servers?
+        AIA.config&.mcp_servers && !AIA.config.mcp_servers.empty?
+      end
+
+      def mcp_server_names
+        return [] unless mcp_servers?
+        AIA.config.mcp_servers.map { |s| s[:name] || s["name"] }.compact
+      end
+
       def supports_tools?
         AIA.config&.client&.model&.supports_functions? || false
       end
@@ -46,6 +55,8 @@ module AIA
           'unknown-model'
         end
 
+        mcp_line = mcp_servers? ? "MCP: #{mcp_server_names.join(', ')}" : ''
+
         puts <<-ROBOT
 
        ,      ,
@@ -55,7 +66,7 @@ module AIA
        __||__    \\) model db was last refreshed on
      [/______\\]  /    #{AIA.config&.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?

data/lib/extensions/openstruct_merge.rb

@@ -21,7 +21,11 @@ class OpenStruct
   end
 
   # Sets value in result OpenStruct, handling nested OpenStruct and Hash objects
+  # Skip nil values to avoid overwriting existing values with nil
   def self.set_value(result, key, value)
+    # Skip nil values - don't overwrite existing values with nil
+    return if value.nil?
+
     if value.is_a?(OpenStruct) || value.is_a?(Hash)
       current_value = result[key]
       current_value = {} if current_value.nil?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aia
 version: !ruby/object:Gem::Version
-  version: 0.9.22
+  version: 0.9.24
 platform: ruby
 authors:
 - Dewayne VanHoozer
@@ -426,8 +426,8 @@ files:
 - lib/aia/config/defaults.rb
 - lib/aia/config/file_loader.rb
 - lib/aia/config/validator.rb
-- lib/aia/context_manager.rb
 - lib/aia/directive_processor.rb
+- lib/aia/directives/checkpoint.rb
 - lib/aia/directives/configuration.rb
 - lib/aia/directives/execution.rb
 - lib/aia/directives/models.rb
@@ -439,6 +439,7 @@ files:
 - lib/aia/prompt_handler.rb
 - lib/aia/ruby_llm_adapter.rb
 - lib/aia/session.rb
+- lib/aia/topic_context.rb
 - lib/aia/ui_presenter.rb
 - lib/aia/utility.rb
 - lib/aia/version.rb
@@ -477,7 +478,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.2
+rubygems_version: 4.0.1
 specification_version: 4
 summary: Multi-model AI CLI with dynamic prompts, consensus responses, shell & Ruby
   integration, and seamless chat workflows.

data/lib/aia/context_manager.rb

@@ -1,134 +0,0 @@
-# lib/aia/context_manager.rb
-
-module AIA
-  # Manages the conversation context for chat sessions.
-  class ContextManager
-    attr_reader :context, :checkpoints
-
-    # Initializes the ContextManager with an optional system prompt.
-    def initialize(system_prompt: nil)
-      @context = []
-      @checkpoints = {}
-      @checkpoint_counter = 0
-      add_system_prompt(system_prompt) if system_prompt && !system_prompt.strip.empty?
-    end
-
-    # Adds a message to the conversation context.
-    #
-    # @param role [String] The role of the message sender ('user' or 'assistant').
-    # @param content [String] The content of the message.
-    def add_to_context(role:, content:)
-      @context << { role: role, content: content }
-    end
-
-    # Returns the current conversation context.
-    # Optionally adds the system prompt if it wasn't added during initialization
-    # or needs to be re-added after clearing.
-    #
-    # @param system_prompt [String, nil] The system prompt to potentially prepend.
-    # @return [Array<Hash>] The conversation context array.
-    def get_context(system_prompt: nil)
-      # Add or replace system prompt if provided and not empty
-      if system_prompt && !system_prompt.strip.empty?
-        add_system_prompt(system_prompt)
-      end
-      @context
-    end
-
-    # Clears the conversation context, optionally keeping the system prompt.
-    #
-    # @param keep_system_prompt [Boolean] Whether to retain the initial system prompt.
-    def clear_context(keep_system_prompt: true)
-      if keep_system_prompt && !@context.empty? && @context.first[:role] == 'system'
-        @context = [@context.first]
-      else
-        @context = []
-      end
-
-      # Clear all checkpoints when clearing context
-      @checkpoints.clear
-      @checkpoint_counter = 0
-
-      # Attempt to clear the LLM client's context as well
-      begin
-        if AIA.config.client && AIA.config.client.respond_to?(:clear_context)
-          AIA.config.client.clear_context
-        end
-
-        if AIA.config.respond_to?(:llm) && AIA.config.llm && AIA.config.llm.respond_to?(:clear_context)
-          AIA.config.llm.clear_context
-        end
-
-        if defined?(RubyLLM) && RubyLLM.respond_to?(:chat) && RubyLLM.chat.respond_to?(:clear_history)
-          RubyLLM.chat.clear_history
-        end
-      rescue => e
-        STDERR.puts "ERROR: context_manager clear_context error #{e.message}"
-      end
-    end
-
-    # Creates a checkpoint of the current context with an optional name.
-    #
-    # @param name [String, nil] The name of the checkpoint. If nil, uses an incrementing integer.
-    # @return [String] The name of the created checkpoint.
-    def create_checkpoint(name: nil)
-      if name.nil?
-        @checkpoint_counter += 1
-        name = @checkpoint_counter.to_s
-      end
-
-      # Store a deep copy of the current context and its position
-      @checkpoints[name] = {
-        context: @context.map(&:dup),
-        position: @context.size
-      }
-      @last_checkpoint_name = name
-      name
-    end
-
-    # Restores the context to a previously saved checkpoint.
-    #
-    # @param name [String, nil] The name of the checkpoint to restore. If nil, uses the last checkpoint.
-    # @return [Boolean] True if restore was successful, false otherwise.
-    def restore_checkpoint(name: nil)
-      name = @last_checkpoint_name if name.nil?
-
-      return false if name.nil? || !@checkpoints.key?(name)
-
-      # Restore the context from the checkpoint
-      checkpoint_data = @checkpoints[name]
-      @context = checkpoint_data[:context].map(&:dup)
-      true
-    end
-
-    # Returns the list of available checkpoint names.
-    #
-    # @return [Array<String>] The names of all checkpoints.
-    def checkpoint_names
-      @checkpoints.keys
-    end
-
-    # Returns checkpoint information mapped to context positions.
-    #
-    # @return [Hash<Integer, Array<String>>] Position to checkpoint names mapping.
-    def checkpoint_positions
-      positions = {}
-      @checkpoints.each do |name, data|
-        position = data[:position]
-        positions[position] ||= []
-        positions[position] << name
-      end
-      positions
-    end
-
-    private
-
-    # Adds or replaces the system prompt at the beginning of the context.
-    def add_system_prompt(system_prompt)
-       # Remove existing system prompt if present
-       @context.shift if !@context.empty? && @context.first[:role] == 'system'
-       # Add the new system prompt at the beginning
-       @context.unshift({ role: 'system', content: system_prompt })
-    end
-  end
-end