aia 0.8.5 → 0.9.0

data/lib/aia/config.rb

@@ -9,6 +9,9 @@ require 'yaml'
 require 'toml-rb'
 require 'erb'
 require 'optparse'
+require 'json'
+require 'tempfile'
+require 'fileutils'
 
 module AIA
   class Config
@@ -26,10 +29,14 @@ module AIA
       role:         '',
       system_prompt: '',
 
+      # MCP configuration
+      mcp_servers:   [],
+      allowed_tools: nil, # nil means all tools are allowed; otherwise an Array of Strings which are the tool names
+
       # Flags
       markdown: true,
-      shell:    false,
-      erb:      false,
+      shell:    true,
+      erb:      true,
       chat:     false,
       clear:    false,
       terse:    false,
@@ -60,6 +67,7 @@ module AIA
       speech_model:         'tts-1',
       transcription_model:  'whisper-1',
       voice:                'alloy',
+      adapter:              'ruby_llm', # 'ruby_llm' or ???
 
       # Embedding parameters
       embedding_model: 'text-embedding-ada-002',
@@ -192,6 +200,13 @@ module AIA
         PromptManager::Prompt.parameter_regex = Regexp.new(config.parameter_regex)
       end
 
+      debug_me{[ 'config.mcp_servers' ]}
+
+      unless config.mcp_servers.empty?
+        # create a single JSON file contain all of the MCP server definitions specified my the --mcp option
+        config.mcp_servers = combine_mcp_server_json_files config.mcp_servers
+      end
+
       config
     end
 
@@ -236,19 +251,23 @@ module AIA
           puts "Debug: Setting chat mode to true" if config.debug
         end
 
-        opts.on("-m MODEL", "--model MODEL", "Name of the LLM model to use") do |model|
-          config.model = model
+        opts.on("--adapter ADAPTER", "Interface that adapts AIA to the LLM") do |adapter|
+          adapter.downcase!
+          valid_adapters = %w[ ruby_llm ]  # NOTE: Add additional adapters here when needed
+          if valid_adapters.include? adapter
+            config.adapter = adapter
+          else
+            STDERR.puts "ERROR: Invalid adapter #{adapter} must be one of these: #{valid_adapters.join(', ')}"
+            exit 1
+          end
         end
 
-        opts.on("--shell", "Enables `aia` to access your terminal's shell environment from inside the prompt text, allowing for dynamic content insertion using system environment variables and shell commands. Includes safety features to confirm or block dangerous commands.") do
-          config.shell = true
-        end
 
-        opts.on("--erb", "Turns the prompt text file into a fully functioning ERB template, allowing for embedded Ruby code processing within the prompt text. This enables dynamic content generation and complex logic within prompts.") do
-          config.erb = true
+        opts.on("-m MODEL", "--model MODEL", "Name of the LLM model to use") do |model|
+          config.model = model
         end
 
-        opts.on("--terse", "Add terse instruction to prompt") do
+        opts.on("--terse", "Adds a special instruction to the prompt asking the AI to keep responses short and to the point") do
           config.terse = true
         end
 
@@ -415,6 +434,44 @@ module AIA
         opts.on("--rq LIBS", "Ruby libraries to require for Ruby directive") do |libs|
           config.require_libs = libs.split(',')
         end
+
+        opts.on("--mcp FILE", "Add MCP server configuration from JSON file. Can be specified multiple times.") do |file|
+          # debug_me FIXME ruby-mcp-client is looking for a single JSON file that
+          # could contain multiple server definitions that looks like this:
+          # {
+          #   "mcpServers": {
+          #     "server one": { ... },
+          #     "server two": { ... }, ....
+          #   }
+          # }
+          # FIXME: need to rurn multiple JSON files into one.
+          if AIA.good_file?(file)
+            config.mcp_servers ||= []
+            config.mcp_servers << file
+            begin
+              server_config = JSON.parse(File.read(file))
+              config.mcp_servers_config ||= []
+              config.mcp_servers_config << server_config
+            rescue JSON::ParserError => e
+              STDERR.puts "Error parsing MCP server config file #{file}: #{e.message}"
+              exit 1
+            end
+          else
+            STDERR.puts "MCP server config file not found: #{file}"
+            exit 1
+          end
+        end
+
+        opts.on("--at", "--allowed_tools TOOLS_LIST", "Allow only these tools to be used") do |tools_list|
+          config.allowed_tools ||= []
+          if tools_list.empty?
+            STDERR.puts "No list of tool names provided for --allowed_tools option"
+            exit 1
+          else
+            config.allowed_tools += tools_list.split(',').map(&:strip)
+            config.allowed_tools.uniq!
+          end
+        end
       end
 
       args = ARGV.dup
@@ -500,5 +557,95 @@ module AIA
       File.write(file, content)
       puts "Config successfully dumped to #{file}"
     end
+
+
+    # Combine multiple MCP server JSON files into a single file
+    def self.combine_mcp_server_json_files(file_paths)
+      raise ArgumentError, "No JSON files provided" if file_paths.nil? || file_paths.empty?
+
+      # The output will have only one top-level key: "mcpServers"
+      mcp_servers = {} # This will store all collected server_name => server_config pairs
+
+      file_paths.each do |file_path|
+        file_content = JSON.parse(File.read(file_path))
+        # Clean basename, e.g., "filesystem.json" -> "filesystem", "foo.json.erb" -> "foo"
+        cleaned_basename = File.basename(file_path).sub(/\.json\.erb$/, '').sub(/\.json$/, '')
+
+        if file_content.is_a?(Hash)
+          if file_content.key?("mcpServers") && file_content["mcpServers"].is_a?(Hash)
+            # Case A: {"mcpServers": {"name1": {...}, "name2": {...}}}
+            file_content["mcpServers"].each do |server_name, server_data|
+              if mcp_servers.key?(server_name)
+                STDERR.puts "Warning: Duplicate MCP server name '#{server_name}' found. Overwriting with definition from #{file_path}."
+              end
+              mcp_servers[server_name] = server_data
+            end
+          # Check if the root hash itself is a single server definition
+          elsif is_single_server_definition?(file_content)
+            # Case B: {"type": "stdio", ...} or {"url": "...", ...}
+            # Use "name" property from JSON if present, otherwise use cleaned_basename
+            server_name = file_content["name"] || cleaned_basename
+            if mcp_servers.key?(server_name)
+              STDERR.puts "Warning: Duplicate MCP server name '#{server_name}' (from file #{file_path}). Overwriting."
+            end
+            mcp_servers[server_name] = file_content
+          else
+            # Case D: Fallback for {"custom_name1": {server_config1}, "custom_name2": {server_config2}}
+            # This assumes top-level keys are server names and values are server configs.
+            file_content.each do |server_name, server_data|
+              if server_data.is_a?(Hash) && is_single_server_definition?(server_data)
+                if mcp_servers.key?(server_name)
+                  STDERR.puts "Warning: Duplicate MCP server name '#{server_name}' found in #{file_path}. Overwriting."
+                end
+                mcp_servers[server_name] = server_data
+              else
+                STDERR.puts "Warning: Unrecognized structure for key '#{server_name}' in #{file_path}. Value is not a valid server definition. Skipping."
+              end
+            end
+          end
+        elsif file_content.is_a?(Array)
+          # Case C: [ {server_config1}, {server_config2_with_name} ]
+          file_content.each_with_index do |server_data, index|
+            if server_data.is_a?(Hash) && is_single_server_definition?(server_data)
+              # Use "name" property from JSON if present, otherwise generate one
+              server_name = server_data["name"] || "#{cleaned_basename}_#{index}"
+              if mcp_servers.key?(server_name)
+                STDERR.puts "Warning: Duplicate MCP server name '#{server_name}' (from array in #{file_path}). Overwriting."
+              end
+              mcp_servers[server_name] = server_data
+            else
+              STDERR.puts "Warning: Unrecognized item in array in #{file_path} at index #{index}. Skipping."
+            end
+          end
+        else
+          STDERR.puts "Warning: Unrecognized JSON structure in #{file_path}. Skipping."
+        end
+      end
+
+      # Create the final output structure
+      output    = {"mcpServers" => mcp_servers}
+      temp_file = Tempfile.new(['combined', '.json'])
+      temp_file.write(JSON.pretty_generate(output))
+      temp_file.close
+
+      temp_file.path
+    end
+
+    # Helper method to determine if a hash represents a valid MCP server definition
+    def self.is_single_server_definition?(config)
+      return false unless config.is_a?(Hash)
+      type = config['type']
+      if type
+        return true if type == 'stdio' && config.key?('command')
+        return true if type == 'sse' && config.key?('url')
+        # Potentially other explicit types if they exist in MCP
+        return false # Known type but missing required fields for it, or unknown type
+      else
+        # Infer type
+        return true if config.key?('command') || config.key?('args') || config.key?('env') # stdio
+        return true if config.key?('url') # sse
+      end
+      false
+    end
   end
 end

data/lib/aia/prompt_handler.rb

@@ -49,6 +49,7 @@ module AIA
           envar_flag: AIA.config.shell
         )
 
+        # Parameters should be extracted during initialization or to_s
         return prompt if prompt
       else
         puts "Warning: Invalid prompt ID or file not found: #{prompt_id}"
@@ -140,8 +141,11 @@ module AIA
     end
 
 
+    # FIXME: original implementation used a search_proc to look into the content of the prompt
+    #        files.  The use of the select statement does not work.
     def search_prompt_id_with_fzf(initial_query)
-      prompt_files = Dir.glob(File.join(@prompts_dir, "*.txt")).map { |file| File.basename(file, ".txt") }
+      prompt_files = Dir.glob(File.join(@prompts_dir, "*.txt"))
+                       .map { |file| File.basename(file, ".txt") }
       fzf = AIA::Fzf.new(
         list: prompt_files,
         directory: @prompts_dir,
@@ -153,7 +157,8 @@ module AIA
     end
 
     def search_role_id_with_fzf(initial_query)
-      role_files = Dir.glob(File.join(@roles_dir, "*.txt")).map { |file| File.basename(file, ".txt") }
+      role_files = Dir.glob(File.join(@roles_dir, "*.txt"))
+                    .map { |file| File.basename(file, ".txt") }
       fzf = AIA::Fzf.new(
         list: role_files,
         directory: @prompts_dir,

data/lib/aia/ruby_llm_adapter.rb

@@ -0,0 +1,225 @@
+# lib/aia/ruby_llm_adapter.rb
+
+require 'ruby_llm'
+require 'mcp_client'
+
+module AIA
+  class RubyLLMAdapter
+    def initialize
+
+      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.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)
+
+        # 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_session_token = ENV.fetch('AWS_SESSION_TOKEN', nil)
+      end
+
+      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)
+      elsif @model.downcase.include?('vision') || @model.downcase.include?('image')
+        image_to_text(prompt)
+      elsif @model.downcase.include?('tts') || @model.downcase.include?('speech')
+        text_to_audio(prompt)
+      elsif @model.downcase.include?('whisper') || @model.downcase.include?('transcription')
+        audio_to_text(prompt)
+      else
+        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
+        # Try using a TTS API if available
+        # For now, we'll use a mock implementation
+        File.write(output_file, "Mock TTS audio content")
+        system("#{AIA.config.speak_command} #{output_file}") if File.exist?(output_file) && system("which #{AIA.config.speak_command} > /dev/null 2>&1")
+        "Audio generated and saved to: #{output_file}"
+      rescue => e
+        "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
+
+    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]
+      else
+        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
+      elsif prompt.is_a?(Hash) && prompt[:text]
+        prompt[:text]
+      elsif prompt.is_a?(Hash) && prompt[:content]
+        prompt[:content]
+      else
+        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,
+                      size: AIA.config.image_size,
+                      quality: AIA.config.image_quality,
+                      style: AIA.config.image_style)
+        "Image generated and saved to: #{output_file}"
+      rescue => e
+        "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 })
+        rescue => e
+          "Error analyzing image: #{e.message}"
+        end
+      else
+        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
+        File.write(output_file, text_prompt)
+        system("#{AIA.config.speak_command} #{output_file}") if File.exist?(output_file) && system("which #{AIA.config.speak_command} > /dev/null 2>&1")
+        "Audio generated and saved to: #{output_file}"
+      rescue => e
+        "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')
+        begin
+          @chat.ask("Transcribe this audio", with: { audio: prompt })
+        rescue => e
+          "Error transcribing audio: #{e.message}"
+        end
+      else
+        # Fall back to regular chat if no valid audio file is found
+        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
+      elsif prompt.is_a?(Hash)
+        prompt[:image] || prompt[:image_path]
+      else
+        nil
+      end
+    end
+  end
+end