aia 0.8.6 → 0.9.1

data/lib/aia/ruby_llm_adapter.rb

@@ -1,32 +1,44 @@
 # lib/aia/ruby_llm_adapter.rb
-#
 
 require 'ruby_llm'
+require 'mcp_client'
 
 module AIA
   class RubyLLMAdapter
     def initialize
-      @model = AIA.config.model
+
+      debug_me('=== RubyLLMAdapter ===')
+
+      @model     = AIA.config.model
       model_info = extract_model_parts(@model)
-      
+
       # Configure RubyLLM with available API keys
       RubyLLM.configure do |config|
-        config.openai_api_key = ENV.fetch('OPENAI_API_KEY', nil)
+        config.openai_api_key    = ENV.fetch('OPENAI_API_KEY', nil)
         config.anthropic_api_key = ENV.fetch('ANTHROPIC_API_KEY', nil)
-        config.gemini_api_key = ENV.fetch('GEMINI_API_KEY', nil)
-        config.deepseek_api_key = ENV.fetch('DEEPSEEK_API_KEY', nil)
-        
+        config.gemini_api_key    = ENV.fetch('GEMINI_API_KEY', nil)
+        config.deepseek_api_key  = ENV.fetch('DEEPSEEK_API_KEY', nil)
+
         # Bedrock configuration
-        config.bedrock_api_key = ENV.fetch('AWS_ACCESS_KEY_ID', nil)
-        config.bedrock_secret_key = ENV.fetch('AWS_SECRET_ACCESS_KEY', nil)
-        config.bedrock_region = ENV.fetch('AWS_REGION', nil)
+        config.bedrock_api_key       = ENV.fetch('AWS_ACCESS_KEY_ID', nil)
+        config.bedrock_secret_key    = ENV.fetch('AWS_SECRET_ACCESS_KEY', nil)
+        config.bedrock_region        = ENV.fetch('AWS_REGION', nil)
         config.bedrock_session_token = ENV.fetch('AWS_SESSION_TOKEN', nil)
       end
-      
-      # Initialize chat with the specified model
+
+      debug_me{[ :model_info ]}
+
+      mcp_client, mcp_tools = generate_mcp_tools(model_info[:provider])
+
+      debug_me{[ :mcp_tools ]}
+
+      if mcp_tools && !mcp_tools.empty?
+        RubyLLM::Chat.with_mcp(client: mcp_client, call_tool_method: :call_tool, tools: mcp_tools)
+      end
+
       @chat = RubyLLM.chat(model: model_info[:model])
     end
-    
+
     def chat(prompt)
       if @model.downcase.include?('dall-e') || @model.downcase.include?('image-generation')
         text_to_image(prompt)
@@ -40,14 +52,14 @@ module AIA
         text_to_text(prompt)
       end
     end
-    
+
     def transcribe(audio_file)
       @chat.ask("Transcribe this audio", with: { audio: audio_file })
     end
-    
+
     def speak(text)
       output_file = "#{Time.now.to_i}.mp3"
-      
+
       # Note: RubyLLM doesn't have a direct text-to-speech feature
       # This is a placeholder for a custom implementation or external service
       begin
@@ -60,25 +72,121 @@ module AIA
         "Error generating audio: #{e.message}"
       end
     end
-    
+
     def method_missing(method, *args, &block)
+      debug_me(tag: '== missing ==', levels: 25){[ :method, :args ]}
       if @chat.respond_to?(method)
         @chat.public_send(method, *args, &block)
       else
         super
       end
     end
-    
+
+    # Clear the chat context/history
+    # Needed for the //clear directive
+    def clear_context
+      AIA.debug_me(tag: '== AGGRESSIVELY clearing LLM context ==') do
+        begin
+          # Option 1: Directly clear the messages array in the current chat object
+          if @chat.instance_variable_defined?(:@messages)
+            AIA.debug_me("Directly clearing @messages array")
+            old_messages = @chat.instance_variable_get(:@messages)
+            AIA.debug_me{[:old_messages, old_messages.length]}
+            # Force a completely empty array, not just attempting to clear it
+            @chat.instance_variable_set(:@messages, [])
+          end
+
+          # Option 2: Force RubyLLM to create a new chat instance at the global level
+          # This ensures any shared state is reset
+          AIA.debug_me("Force global RubyLLM chat reset")
+          model_info = extract_model_parts(@model)
+          RubyLLM.instance_variable_set(:@chat, nil) if RubyLLM.instance_variable_defined?(:@chat)
+          
+          # Option 3: Create a completely fresh chat instance for this adapter
+          @chat = nil  # First nil it to help garbage collection
+          @chat = RubyLLM.chat(model: model_info[:model])
+          AIA.debug_me("Created fresh RubyLLM::Chat instance")
+          
+          # Option 4: Call official clear_history method if it exists
+          if @chat.respond_to?(:clear_history)
+            AIA.debug_me("Calling clear_history method")
+            @chat.clear_history
+          end
+          
+          # Option 5: If chat has messages, force set it to empty again as a final check
+          if @chat.instance_variable_defined?(:@messages) && !@chat.instance_variable_get(:@messages).empty?
+            AIA.debug_me("FINAL CHECK: @messages still not empty, forcing empty")
+            @chat.instance_variable_set(:@messages, [])
+          end
+          
+          # Reset any MCP tools configuration
+          begin
+            mcp_client, mcp_tools = generate_mcp_tools(model_info[:provider])
+            if mcp_tools && !mcp_tools.empty?
+              AIA.debug_me("Reconfiguring MCP tools")
+              RubyLLM::Chat.with_mcp(client: mcp_client, call_tool_method: :call_tool, tools: mcp_tools)
+            end
+          rescue => mcp_error
+            AIA.debug_me{[:mcp_error, mcp_error.message]}
+          end
+          
+          # Final verification
+          new_messages = @chat.instance_variable_defined?(:@messages) ? @chat.instance_variable_get(:@messages) : []
+          AIA.debug_me{[:new_messages, new_messages.length]}
+          
+          return "Chat context successfully cleared."
+        rescue => e
+          AIA.debug_me{
+            [ :e, e.message, e.backtrace ]
+          }
+          return "Error clearing chat context: #{e.message}"
+        end
+      end
+    end
+
     def respond_to_missing?(method, include_private = false)
       @chat.respond_to?(method) || super
     end
-    
+
     private
-    
+
+    # Generate an array of MCP tools, filtered and formatted for the correct provider.
+    # @param config [OpenStruct] the config object containing mcp_servers, allowed_tools, and model
+    # @return [Array<Hash>, nil] the filtered and formatted MCP tools or nil if no tools
+    def generate_mcp_tools(provider)
+      return [nil, nil] unless AIA.config.mcp_servers && !AIA.config.mcp_servers.empty?
+
+      debug_me('=== generate_mcp_tools ===')
+
+      # AIA.config.mcp_servers is now a path to the combined JSON file
+      mcp_client     = MCPClient.create_client(server_definition_file: AIA.config.mcp_servers)
+      debug_me
+      all_tools      = mcp_client.list_tools(cache: false).map(&:name)
+      debug_me
+      allowed        = AIA.config.allowed_tools
+      debug_me
+      filtered_tools = allowed.nil? ? all_tools : all_tools & allowed
+      debug_me{[ :filtered_tools ]}
+
+      debug_me{[ :provider ]}
+
+      mcp_tools = if :anthropic == provider.to_sym
+                    debug_me
+                    mcp_client.to_anthropic_tools(tool_names: filtered_tools)
+                  else
+                    debug_me
+                    mcp_client.to_openai_tools(tool_names: filtered_tools)
+                  end
+      [mcp_client, mcp_tools]
+    rescue => e
+      STDERR.puts "ERROR: Failed to generate MCP tools: #{e.message}"
+      nil
+    end
+
     def extract_model_parts(model_string)
       parts = model_string.split('/')
       parts.map!(&:strip)
-      
+
       if parts.length > 1
         provider = parts[0]
         model = parts[1]
@@ -86,10 +194,10 @@ module AIA
         provider = nil # RubyLLM will figure it out from the model name
         model = parts[0]
       end
-      
+
       { provider: provider, model: model }
     end
-    
+
     def extract_text_prompt(prompt)
       if prompt.is_a?(String)
         prompt
@@ -101,18 +209,18 @@ module AIA
         prompt.to_s
       end
     end
-    
+
     def text_to_text(prompt)
       text_prompt = extract_text_prompt(prompt)
       @chat.ask(text_prompt)
     end
-    
+
     def text_to_image(prompt)
       text_prompt = extract_text_prompt(prompt)
       output_file = "#{Time.now.to_i}.png"
-      
+
       begin
-        RubyLLM.paint(text_prompt, output_path: output_file, 
+        RubyLLM.paint(text_prompt, output_path: output_file,
                       size: AIA.config.image_size,
                       quality: AIA.config.image_quality,
                       style: AIA.config.image_style)
@@ -121,11 +229,11 @@ module AIA
         "Error generating image: #{e.message}"
       end
     end
-    
+
     def image_to_text(prompt)
       image_path = extract_image_path(prompt)
       text_prompt = extract_text_prompt(prompt)
-      
+
       if image_path && File.exist?(image_path)
         begin
           @chat.ask(text_prompt, with: { image: image_path })
@@ -136,11 +244,11 @@ module AIA
         text_to_text(prompt)
       end
     end
-    
+
     def text_to_audio(prompt)
       text_prompt = extract_text_prompt(prompt)
       output_file = "#{Time.now.to_i}.mp3"
-      
+
       begin
         # Note: RubyLLM doesn't have a direct TTS feature
         # This is a placeholder for a custom implementation
@@ -151,7 +259,7 @@ module AIA
         "Error generating audio: #{e.message}"
       end
     end
-    
+
     def audio_to_text(prompt)
       if prompt.is_a?(String) && File.exist?(prompt) &&
          prompt.downcase.end_with?('.mp3', '.wav', '.m4a', '.flac')
@@ -165,7 +273,7 @@ module AIA
         text_to_text(prompt)
       end
     end
-    
+
     def extract_image_path(prompt)
       if prompt.is_a?(String)
         prompt.scan(/\b[\w\/\.\-]+\.(jpg|jpeg|png|gif|webp)\b/i).first&.first

data/lib/aia/session.rb

@@ -22,6 +22,7 @@ module AIA
 
     def initialize(prompt_handler)
       @prompt_handler  = prompt_handler
+      @chat_prompt_id = nil  # Initialize to nil
 
       # Special handling for chat mode with context files but no prompt ID
       if AIA.chat? && AIA.config.prompt_id.empty? && AIA.config.context_files && !AIA.config.context_files.empty?
@@ -35,8 +36,8 @@ module AIA
         @history_manager = HistoryManager.new(prompt: prompt_instance)
       end
 
-      @context_manager = ContextManager.new(system_prompt: AIA.config.system_prompt) # Add this line
-      @ui_presenter    = UIPresenter.new
+      @context_manager     = ContextManager.new(system_prompt: AIA.config.system_prompt)
+      @ui_presenter        = UIPresenter.new
       @directive_processor = DirectiveProcessor.new
       @chat_processor      = ChatProcessorService.new(@ui_presenter, @directive_processor)
 
@@ -111,7 +112,6 @@ module AIA
       end
 
       prompt.save
-
       # Substitute variables and get final prompt text
       prompt_text = prompt.to_s
 
@@ -151,129 +151,177 @@ module AIA
     end
 
     # Starts the interactive chat session.
+    # NOTE: there could have been an initial prompt sent into this session
+    #       via a prompt_id on the command line, piped in text, or context files.
     def start_chat(skip_context_files: false)
-      # Consider if display_chat_header is needed if robot+separator already shown
-      # For now, let's keep it, maybe add an indicator message
       puts "\nEntering interactive chat mode..."
       @ui_presenter.display_chat_header
 
-      Reline::HISTORY.clear # Keep Reline history for user input editing, separate from chat context
-
-      # Load context files if any and not skipping
-      if !skip_context_files && AIA.config.context_files && !AIA.config.context_files.empty?
-        context_content = AIA.config.context_files.map do |file|
-          File.read(file) rescue "Error reading file: #{file}"
-        end.join("\n\n")
-
-        if !context_content.empty?
-          # Add context files content to context
-          @context_manager.add_to_context(role: 'user', content: context_content)
-
-          # Process the context
-          operation_type = @chat_processor.determine_operation_type(AIA.config.model)
-          @ui_presenter.display_thinking_animation
-          response = @chat_processor.process_prompt(@context_manager.get_context, operation_type)
-
-          # Add AI response to context
-          @context_manager.add_to_context(role: 'assistant', content: response)
+      # Generate chat prompt ID
+      now = Time.now
+      @chat_prompt_id = "chat_#{now.strftime('%Y%m%d_%H%M%S')}"
 
-          # Output the response
-          @chat_processor.output_response(response)
-          @chat_processor.speak(response)
-          @ui_presenter.display_separator
+      # Create the temporary prompt
+      begin
+        # Create the unique? prompt ID in the file storage system with its initial text
+        PromptManager::Prompt.create(
+          id: @chat_prompt_id,
+          text: "Today's date is #{now.strftime('%Y-%m-%d')} and the current time is #{now.strftime('%H:%M:%S')}"
+        )
+
+        # Capture self for the handlers
+        session_instance = self
+
+        # Set up cleanup handlers only after prompt is created
+        at_exit { session_instance.send(:cleanup_chat_prompt) }
+        Signal.trap('INT') {
+          session_instance.send(:cleanup_chat_prompt)
+          exit
+        }
+
+        # Access this chat session's prompt object in order to do the dynamic things
+        # in follow up prompts that can be done in the batch mode like shell substitution. etc.
+        @chat_prompt = PromptManager::Prompt.new(
+          id: @chat_prompt_id,
+          directives_processor: @directive_processor,
+          erb_flag:             AIA.config.erb,
+          envar_flag:           AIA.config.shell,
+          external_binding:     binding,
+        )
+
+        Reline::HISTORY.clear
+
+        # Load context files if any and not skipping
+        if !skip_context_files && AIA.config.context_files && !AIA.config.context_files.empty?
+          context = AIA.config.context_files.map do |file|
+            File.read(file) rescue "Error reading file: #{file}"
+          end.join("\n\n")
+
+          if !context.empty?
+            # Add context files content to context
+            @context_manager.add_to_context(role: 'user', content: context)
+
+            # Process the context
+            operation_type = @chat_processor.determine_operation_type(AIA.config.model)
+            @ui_presenter.display_thinking_animation
+            response = @chat_processor.process_prompt(@context_manager.get_context, operation_type)
+
+            # Add AI response to context
+            @context_manager.add_to_context(role: 'assistant', content: response)
+
+            # Output the response
+            @chat_processor.output_response(response)
+            @chat_processor.speak(response)
+            @ui_presenter.display_separator
+          end
         end
-      end
-
-      # Check for piped input (STDIN not a TTY and has data)
-      if !STDIN.tty?
-        # Save the original STDIN
-        original_stdin = STDIN.dup
 
-        # Read the piped input
-        piped_input = STDIN.read.strip
+        # Handle piped input
+        if !STDIN.tty?
+          original_stdin = STDIN.dup
+          piped_input = STDIN.read.strip
+          STDIN.reopen('/dev/tty')
 
-        # Reopen STDIN to the terminal
-        STDIN.reopen('/dev/tty')
+          if !piped_input.empty?
+            @chat_prompt.text = piped_input
+            processed_input = @chat_prompt.to_s
 
-        if !piped_input.empty?
-          # Add piped input to context
-          @context_manager.add_to_context(role: 'user', content: piped_input)
+            @context_manager.add_to_context(role: 'user', content: processed_input)
 
-          # Process the piped input
-          operation_type = @chat_processor.determine_operation_type(AIA.config.model)
-          @ui_presenter.display_thinking_animation
-          response = @chat_processor.process_prompt(@context_manager.get_context, operation_type)
+            operation_type = @chat_processor.determine_operation_type(AIA.config.model)
+            @ui_presenter.display_thinking_animation
+            response = @chat_processor.process_prompt(@context_manager.get_context, operation_type)
 
-          # Add AI response to context
-          @context_manager.add_to_context(role: 'assistant', content: response)
+            @context_manager.add_to_context(role: 'assistant', content: response)
+            @chat_processor.output_response(response)
+            @chat_processor.speak(response) if AIA.speak?
+            @ui_presenter.display_separator
+          end
 
-          # Output the response
-          @chat_processor.output_response(response)
-          @chat_processor.speak(response) if AIA.speak?
-          @ui_presenter.display_separator
+          STDIN.reopen(original_stdin)
         end
-        
-        # Restore original stdin when done with piped input processing
-        STDIN.reopen(original_stdin)
-      end
-
-      loop do
-        # Get user input
-        prompt = @ui_presenter.ask_question
 
+        # Main chat loop
+        loop do
+          follow_up_prompt = @ui_presenter.ask_question
 
+          break if follow_up_prompt.nil? || follow_up_prompt.strip.downcase == 'exit' || follow_up_prompt.strip.empty?
 
-        break if prompt.nil? || prompt.strip.downcase == 'exit' || prompt.strip.empty?
-
-        if AIA.config.out_file
-          File.open(AIA.config.out_file, 'a') do |file|
-            file.puts "\nYou: #{prompt}"
+          if AIA.config.out_file
+            File.open(AIA.config.out_file, 'a') do |file|
+              file.puts "\nYou: #{follow_up_prompt}"
+            end
           end
-        end
 
-        if @directive_processor.directive?(prompt)
-          directive_output = @directive_processor.process(prompt, @context_manager) # Pass context_manager
-
-          # Add check for specific directives like //clear that might modify context
-          if prompt.strip.start_with?('//clear')
-             # Context is likely cleared within directive_processor.process now
-             # or add @context_manager.clear_context here if not handled internally
-             @ui_presenter.display_info("Chat context cleared.")
-             next # Skip API call after clearing
-          elsif directive_output.nil? || directive_output.strip.empty?
-            next # Skip API call if directive produced no output and wasn't //clear
-          else
-            puts "\n#{directive_output}\n"
-            # Optionally add directive output to context or handle as needed
-            # Example: Add a summary to context
-            # @context_manager.add_to_context(role: 'assistant', content: "Directive executed. Output:\n#{directive_output}")
-            # For now, just use a placeholder prompt modification:
-            prompt = "I executed this directive: #{prompt}\nHere's the output: #{directive_output}\nLet's continue our conversation."
-             # Fall through to add this modified prompt to context and send to AI
+          if @directive_processor.directive?(follow_up_prompt)
+            directive_output = @directive_processor.process(follow_up_prompt, @context_manager)
+
+            if follow_up_prompt.strip.start_with?('//clear')
+               # The directive processor has called context_manager.clear_context
+               # but we need a more aggressive approach to fully clear all context
+               
+               # First, clear the context manager's context
+               @context_manager.clear_context(keep_system_prompt: true)
+               
+               # Second, try clearing the client's context
+               if AIA.config.client && AIA.config.client.respond_to?(:clear_context)
+                 AIA.config.client.clear_context
+               end
+               
+               # Third, completely reinitialize the client to ensure fresh state
+               # This is the most aggressive approach to ensure no context remains
+               begin
+                 AIA.config.client = AIA::RubyLLMAdapter.new
+                 AIA.debug_me("Completely reinitialized client for //clear directive")
+               rescue => e
+                 AIA.debug_me("Error reinitializing client: #{e.message}")
+               end
+               
+               @ui_presenter.display_info("Chat context cleared.")
+               next
+            elsif directive_output.nil? || directive_output.strip.empty?
+              next
+            else
+              puts "\n#{directive_output}\n"
+              follow_up_prompt = "I executed this directive: #{follow_up_prompt}\nHere's the output: #{directive_output}\nLet's continue our conversation."
+            end
           end
-        end
-
-        # Use ContextManager instead of HistoryManager
-        @context_manager.add_to_context(role: 'user', content: prompt)
 
-        # Use ContextManager to get the conversation
-        conversation = @context_manager.get_context # System prompt handled internally
+          @chat_prompt.text = follow_up_prompt
+          processed_prompt = @chat_prompt.to_s
 
-        operation_type = @chat_processor.determine_operation_type(AIA.config.model)
-        @ui_presenter.display_thinking_animation
-        response = @chat_processor.process_prompt(conversation, operation_type)
+          @context_manager.add_to_context(role: 'user', content: processed_prompt)
+          conversation = @context_manager.get_context
 
-        @ui_presenter.display_ai_response(response)
+          operation_type = @chat_processor.determine_operation_type(AIA.config.model)
+          @ui_presenter.display_thinking_animation
+          response = @chat_processor.process_prompt(conversation, operation_type)
 
-        # Use ContextManager instead of HistoryManager
-        @context_manager.add_to_context(role: 'assistant', content: response)
+          @ui_presenter.display_ai_response(response)
+          @context_manager.add_to_context(role: 'assistant', content: response)
+          @chat_processor.speak(response)
 
-        @chat_processor.speak(response)
+          @ui_presenter.display_separator
+        end
 
-        @ui_presenter.display_separator
+      ensure
+        @ui_presenter.display_chat_end
       end
+    end
 
-      @ui_presenter.display_chat_end
+    private
+
+    def cleanup_chat_prompt
+      if @chat_prompt_id
+        puts "[DEBUG] Cleaning up chat prompt: #{@chat_prompt_id}" if AIA.debug?
+        begin
+          @chat_prompt.delete
+          @chat_prompt_id = nil # Prevent repeated attempts if error occurs elsewhere
+        rescue => e
+          STDERR.puts "[ERROR] Failed to delete chat prompt #{@chat_prompt_id}: #{e.class} - #{e.message}"
+          STDERR.puts e.backtrace.join("\n")
+        end
+      end
     end
   end
 end

data/lib/aia/ui_presenter.rb

@@ -38,10 +38,19 @@ module AIA
     def format_chat_response(response, output = $stdout)
       indent = '   '
 
+      # Convert RubyLLM::Message to string if necessary
+      response_text = if response.is_a?(RubyLLM::Message)
+                        response.content.to_s
+                      elsif response.respond_to?(:to_s)
+                        response.to_s
+                      else
+                        response
+                      end
+
       in_code_block = false
       language = ''
 
-      response.each_line do |line|
+      response_text.each_line do |line|
         line = line.chomp
 
         # Check for code block delimiters

data/lib/aia.rb

@@ -4,9 +4,12 @@
 # The AIA module serves as the namespace for the AIA application, which
 # provides an interface for interacting with AI models and managing prompts.
 
-require 'ai_client'
 require 'ruby_llm'
+require_relative 'extensions/ruby_llm/chat'
+
 require 'prompt_manager'
+require 'mcp_client'
+
 require 'debug_me'
 include DebugMe
 $DEBUG_ME = false
@@ -18,7 +21,6 @@ require_relative 'aia/version'
 require_relative 'aia/config'
 require_relative 'aia/shell_command_executor'
 require_relative 'aia/prompt_handler'
-require_relative 'aia/ai_client_adapter'
 require_relative 'aia/ruby_llm_adapter'
 require_relative 'aia/directive_processor'
 require_relative 'aia/history_manager'
@@ -78,14 +80,14 @@ module AIA
     end
 
     prompt_handler = PromptHandler.new
-    
+
     # Initialize the appropriate client adapter based on configuration
     @config.client = if @config.adapter == 'ruby_llm'
                       RubyLLMAdapter.new
                     else
                       AIClientAdapter.new
                     end
-                    
+
     session        = Session.new(prompt_handler)
 
     session.start