aia 0.8.5 → 0.9.0

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,126 +151,157 @@ 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
-        orig_stdin = STDIN.dup
+        # Handle piped input
+        if !STDIN.tty?
+          original_stdin = STDIN.dup
+          piped_input = STDIN.read.strip
+          STDIN.reopen('/dev/tty')
 
-        # Read the piped input
-        piped_input = STDIN.read.strip
+          if !piped_input.empty?
+            @chat_prompt.text = piped_input
+            processed_input = @chat_prompt.to_s
 
-        # Reopen STDIN to the terminal
-        STDIN.reopen('/dev/tty')
+            @context_manager.add_to_context(role: 'user', content: processed_input)
 
-        if !piped_input.empty?
-          # Add piped input to context
-          @context_manager.add_to_context(role: 'user', content: 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)
 
-          # 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)
-
-          # 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)
-          @ui_presenter.display_separator
+          STDIN.reopen(original_stdin)
         end
-      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')
+               @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/utility.rb

@@ -11,7 +11,7 @@ module AIA
        (\\____/) AI Assistant
         (_oo_)   #{AIA.config.model}
          (O)      is Online
-       __||__    \\)
+       __||__    \\) using #{AIA.config.adapter}
      [/______\\]  /
     / \\__AI__/ \\/
    /    /__\\

data/lib/aia.rb

@@ -4,8 +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
@@ -17,7 +21,7 @@ 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'
 require_relative 'aia/ui_presenter'
@@ -76,7 +80,14 @@ module AIA
     end
 
     prompt_handler = PromptHandler.new
-    @config.client = AIClientAdapter.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

data/lib/extensions/ruby_llm/chat.rb

@@ -0,0 +1,197 @@
+# lib/extensions/ruby_llm/chat.rb
+
+module RubyLLM
+  class Chat
+    class << self
+      # Sets up Model Control Protocol (MCP) tools
+      #
+      # @param client [instance object] MCP client instance to use
+      # @param call_tool_method [Symbol] Method name to use for tool execution
+      # @param tools [Array<Hash>] Array of MCP tool definitions
+      #
+      # @return [self] Returns self for method chaining
+      #
+      def with_mcp(client:, call_tool_method:, tools:)
+        # Validate all required parameters are present
+        if client.nil?
+          RubyLLM.logger.error "MCP setup failed: client must be provided"
+          return clear_mcp_state
+        end
+
+        if call_tool_method.nil?
+          RubyLLM.logger.error "MCP setup failed: call_tool_method must be provided"
+          return clear_mcp_state
+        end
+
+        if tools.nil?
+          RubyLLM.logger.error "MCP setup failed: tools must be provided"
+          return clear_mcp_state
+        end
+
+        # Validate call_tool_method type
+        unless call_tool_method.is_a?(Symbol) || call_tool_method.is_a?(String)
+          RubyLLM.logger.error "MCP setup failed: call_tool_method must be a Symbol or String, got #{call_tool_method.class}"
+          return clear_mcp_state
+        end
+
+        # Validate client responds to the method
+        unless client.respond_to?(call_tool_method)
+          RubyLLM.logger.error "MCP setup failed: client instance does not respond to call_tool_method #{call_tool_method}"
+          return clear_mcp_state
+        end
+
+        # Set MCP configuration
+        @mcp_client    = client
+        @mcp_call_tool = call_tool_method.to_sym
+        @mcp_tools     = tools
+
+        self
+      end
+
+      # Get the MCP client instance if configured
+      # @return [MCPClient::Client, nil] The MCP client instance or nil if not configured
+      def mcp_client
+        @mcp_client
+      end
+
+      # Get the method name to use for tool execution if configured
+      # @return [Symbol, nil] The method name or nil if not configured
+      def mcp_call_tool
+        @mcp_call_tool
+      end
+
+      # Get the MCP tool definitions if configured
+      # @return [Array<Hash>] The MCP tool definitions or empty array if not configured
+      def mcp_tools
+        @mcp_tools || []
+      end
+
+      private
+
+      # Clear all MCP state and return self
+      # @return [self]
+      def clear_mcp_state
+        @mcp_client    = nil
+        @mcp_call_tool = nil
+        @mcp_tools     = []
+        self
+      end
+    end
+
+    # Prepend a module to add MCP tool support
+    module MCPSupport
+      def initialize(...)
+        super
+        add_mcp_tools
+      end
+
+      private
+
+      def add_mcp_tools
+        self.class.mcp_tools.each do |tool_def|
+          debug_me{[ :tool_def ]}
+          tool_name = tool_def.dig(:function, :name).to_sym
+          next if @tools.key?(tool_name) # Skip if local or MCP tool exists with same name
+
+          @tools[tool_name] = MCPToolWrapper.new(tool_def)
+        end
+      end
+    end
+
+    # Add MCP support to the Chat class
+    prepend MCPSupport
+  end
+
+  # Wraps an MCP tool definition to match the RubyLLM::Tool interface
+  class MCPToolWrapper
+    def initialize(mcp_tool)
+      @mcp_tool = mcp_tool
+    end
+
+    def name
+      @mcp_tool.dig(:function, :name)
+    end
+
+    def description
+      @mcp_tool.dig(:function, :description)
+    end
+
+    # Simple parameter class that implements the interface expected by RubyLLM::Providers::OpenAI::Tools#param_schema
+    class Parameter
+      attr_reader :type, :description, :required
+      
+      def initialize(type, description, required)
+        @type = type || 'string'
+        @description = description
+        @required = required
+      end
+    end
+    
+    def parameters
+      @parameters ||= begin
+        props = @mcp_tool.dig(:function, :parameters, "properties") || {}
+        required_params = @mcp_tool.dig(:function, :parameters, "required") || []
+        
+        # Create Parameter objects with the expected interface
+        # The parameter name is the key in the properties hash
+        result = {}
+        props.each do |param_name, param_def|
+          result[param_name.to_sym] = Parameter.new(
+            param_def["type"],
+            param_def["description"],
+            required_params.include?(param_name)
+          )
+        end
+        result
+      end
+    end
+
+    def call(args)
+      # Log the tool call with arguments
+      RubyLLM.logger.debug "Tool #{name} called with: #{args.inspect}"
+
+      # Verify MCP client is configured properly
+      unless Chat.mcp_client && Chat.mcp_call_tool
+        error = { error: "MCP client not properly configured" }
+        RubyLLM.logger.error error[:error]
+        return error
+      end
+
+      # Handle tool calls that require non-string parameters
+      normalized_args = {}
+      args.each do |key, value|
+        # Convert string numbers to actual numbers when needed
+        if value.is_a?(String) && value.match?(/\A-?\d+(\.\d+)?\z/)
+          param_type = @mcp_tool.dig(:function, :parameters, "properties", key.to_s, "type")
+          if param_type == "number" || param_type == "integer"
+            normalized_args[key] = value.include?('.') ? value.to_f : value.to_i
+            next
+          end
+        end
+        normalized_args[key] = value
+      end
+      
+      # Execute the tool via the MCP client with a timeout
+      timeout = 10 # seconds
+      result = nil
+      
+      begin
+        Timeout.timeout(timeout) do
+          result = Chat.mcp_client.send(Chat.mcp_call_tool, name, normalized_args)
+        end
+      rescue Timeout::Error
+        error = { error: "MCP tool execution timed out after #{timeout} seconds" }
+        RubyLLM.logger.error error[:error]
+        return error
+      rescue StandardError => e
+        error = { error: "MCP tool execution failed: #{e.message}" }
+        RubyLLM.logger.error error[:error]
+        return error
+      end
+
+      # Log the result
+      RubyLLM.logger.debug "Tool #{name} returned: #{result.inspect}"
+      result
+    end
+  end
+end

data/mcp_servers/README.md

@@ -0,0 +1,90 @@
+# MCP Servers
+
+The Model Context Protocol (MCP) enables tools from different server implementations to be defined in a common consistent way, allowing LLMs that support callback functions (aka tools) to access data that enhances the context of a prompt.
+
+You can find additional MCP servers at https://mcpindex.net
+
+## Overview
+
+This directory contains configuration files for various MCP servers that provide different capabilities to LLMs:
+
+| Server | Purpose | Configuration File |
+|--------|---------|--------------------|
+| Filesystem | Provides access to the local filesystem | `filesystem.json` |
+| iMCP | macOS-specific MCP server for system integration | `imcp.json` |
+| Playwright | Enables web automation and scraping capabilities | `playwright_server_definition.json` |
+
+## Configuration Details
+
+### Filesystem Server
+
+The filesystem server allows LLMs to read and interact with the local filesystem:
+
+TODO: fix this JSON file to use a generic directory; maybe $HOME
+
+```json
+{
+  "type": "stdio",
+  "command": [
+    "npx",
+    "-y",
+    "@modelcontextprotocol/server-filesystem",
+    "/Users/dewayne/sandbox/git_repos/madbomber/aia/develop"
+  ]
+}
+```
+
+The server is configured to access files within the project's development directory.
+
+### iMCP Server
+
+See: https://github.com/loopwork-ai/iMCP
+
+The iMCP server provides macOS-specific functionality:
+
+```json
+{
+  "mcpServers" : {
+    "iMCP" : {
+      "command" : "/Applications/iMCP.app/Contents/MacOS/imcp-server"
+    }
+  }
+}
+```
+
+### Playwright Server
+
+The Playwright server enables web automation and browser interaction capabilities:
+
+```json
+{
+  "mcpServers": {
+    "playwright": {
+      "url": "http://localhost:8931/sse",
+      "headers": {},
+      "comment": "Local Playwright MCP Server running on port 8931"
+    }
+  }
+}
+```
+
+## Usage
+
+These MCP servers can be utilized by LLM applications to extend their capabilities beyond text generation. The configuration files in this directory are used to define how to connect to each server and what capabilities they provide.
+
+## Getting Started
+
+Use the --mcp option with aia to specify which MCP servers to use. You may use the --mcp option multiple times to select more than one server. For example:
+
+```bash
+aia prompt_id --mcp filesystem.json --mcp imcp.json --mcp playwright_server_definition.json
+# or
+aia --chat --mcp filesystem.json --mcp imcp.json --mcp playwright_server_definition.json
+# or
+aia prompt_id --chat --mcp filesystem.json --mcp imcp.json --mcp playwright_server_definition.json
+```
+
+## Additional Resources
+
+- [Model Context Protocol Documentation](https://github.com/anthropics/anthropic-cookbook/tree/main/model_context_protocol)
+- [MCP Server Implementation Guidelines](https://modelcontextprotocol.github.io/)

data/mcp_servers/filesystem.json

@@ -0,0 +1,9 @@
+{
+  "type": "stdio",
+  "command": [
+    "npx",
+    "-y",
+    "@modelcontextprotocol/server-filesystem",
+    "/Users/dewayne/sandbox/git_repos/madbomber/aia/develop"
+  ]
+}

data/mcp_servers/imcp.json

@@ -0,0 +1,7 @@
+{
+  "mcpServers" : {
+    "iMCP" : {
+      "command" : "/Applications/iMCP.app/Contents/MacOS/imcp-server"
+    }
+  }
+}

data/mcp_servers/launcher.json

@@ -0,0 +1,11 @@
+{
+  "mcpServers": {
+    "launcher": {
+      "command": "npx",
+      "args": [
+        "y",
+        "@joshuarileydev/mac-apps-launcher-mcp-server"
+      ]
+    }
+  }
+}

data/mcp_servers/playwright_server_definition.json

@@ -0,0 +1,9 @@
+{
+  "mcpServers": {
+    "playwright": {
+      "url": "http://localhost:8931/sse",
+      "headers": {},
+      "comment": "Local Playwright MCP Server running on port 8931"
+    }
+  }
+}