aia 0.9.2 → 0.9.4

data/lib/aia/directive_processor.rb

@@ -4,6 +4,8 @@ require 'faraday'
 
 module AIA
   class DirectiveProcessor
+    using Refinements
+
     PUREMD_API_KEY   = ENV.fetch('PUREMD_API_KEY', nil)
     EXCLUDED_METHODS = %w[ run initialize private? ]
     @descriptions = {}
@@ -57,7 +59,7 @@ module AIA
                else
                  a_string.to_s
                end
-      
+
       content.strip.start_with?(PromptManager::Prompt::DIRECTIVE_SIGNAL)
     end
 
@@ -117,7 +119,6 @@ module AIA
       !respond_to?(method_name) && respond_to?(method_name, true)
     end
 
-
     ################
     ## Directives ##
     ################
@@ -162,6 +163,7 @@ module AIA
       end
       ''
     end
+    alias_method :workflow, :pipeline
 
     desc "Inserts the contents of a file  Example: //include path/to/file"
     def include(args, context_manager=nil)
@@ -240,6 +242,10 @@ module AIA
 
     desc "Clears the conversation history (aka context) same as //config clear = true"
     def clear(args, context_manager=nil)
+      # TODO: review the robot's code in the Session class for when the
+      #       //clear directive is used in a follow up prompt.  That processing
+      #       should be moved here so that it is also available in batch
+      #       sessions.
       if context_manager.nil?
         return "Error: Context manager not available for //clear directive."
       end
@@ -290,6 +296,45 @@ module AIA
       ""
     end
 
+    desc "All Available models or query on [partial LLM or provider name] Examples: //llms ; //llms openai ; //llms claude"
+    def available_models( args=nil, context_manager=nil)
+      query     = args
+      header    = "Available LLMs"
+
+      if query
+        header += " for #{query.join(' and ')}"
+      end
+
+      puts header + ':'
+
+      q1 = query.select{|q| !q.start_with?(':')}
+      q2 = query.select{|q|  q.start_with?(':')}
+
+      RubyLLM.models.all.each do |llm|
+        inputs  = llm.modalities.input.join(',')
+        outputs = llm.modalities.output.join(',')
+        entry   = "- #{llm.id} (#{llm.provider}) #{inputs} to #{outputs}"
+
+        if query.nil? || query.empty?
+          puts entry
+          next
+        end
+
+        show_it = true
+        q1.each{|q| show_it &&= entry.include?(q)}
+        q2.each{|q| show_it &&= llm.modalities.supports?(q)}
+
+        puts entry if show_it
+      end
+
+      ""
+    end
+    alias_method :am,         :available_models
+    alias_method :available,  :available_models
+    alias_method :models,     :available_models
+    alias_method :all_models, :available_models
+    alias_method :llms,       :available_models
+
     desc "Generates this help content"
     def help(args=nil, context_manager=nil)
       puts

data/lib/aia/ruby_llm_adapter.rb

@@ -1,54 +1,121 @@
 # lib/aia/ruby_llm_adapter.rb
 
-require 'ruby_llm'
-
 module AIA
   class RubyLLMAdapter
     attr_reader :tools
 
     def initialize
-      @model     = AIA.config.model
-      model_info = extract_model_parts(@model)
+      @provider, @model = extract_model_parts.values
+
+      configure_rubyllm
+      refresh_local_model_registry
+      setup_chat_with_tools
+    end
 
-      # Configure RubyLLM with available API keys
+    def configure_rubyllm
+      # TODO: Add some of these configuration items to AIA.config
       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)
+        config.openai_api_key         = ENV.fetch('OPENAI_API_KEY', nil)
+        config.openai_organization_id = ENV.fetch('OPENAI_ORGANIZATION_ID', nil)
+        config.openai_project_id      = ENV.fetch('OPENAI_PROJECT_ID', 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.openrouter_api_key = ENV.fetch('OPENROUTER_API_KEY', nil)
+
+        config.bedrock_api_key       = ENV.fetch('BEDROCK_ACCESS_KEY_ID', nil)
+        config.bedrock_secret_key    = ENV.fetch('BEDROCK_SECRET_ACCESS_KEY', nil)
+        config.bedrock_region        = ENV.fetch('BEDROCK_REGION', nil)
+        config.bedrock_session_token = ENV.fetch('BEDROCK_SESSION_TOKEN', nil)
+
+        config.ollama_api_base    = ENV.fetch('OLLAMA_API_BASE', nil)
+
+        # --- Custom OpenAI Endpoint ---
+        # Use this for Azure OpenAI, proxies, or self-hosted models via OpenAI-compatible APIs.
+        config.openai_api_base  = ENV.fetch('OPENAI_API_BASE', nil) # e.g., "https://your-azure.openai.azure.com"
+
+        # --- Default Models ---
+        # Used by RubyLLM.chat, RubyLLM.embed, RubyLLM.paint if no model is specified.
+        # config.default_model            = 'gpt-4.1-nano'            # Default: 'gpt-4.1-nano'
+        # config.default_embedding_model  = 'text-embedding-3-small'  # Default: 'text-embedding-3-small'
+        # config.default_image_model      = 'dall-e-3'                # Default: 'dall-e-3'
+
+        # --- Connection Settings ---
+        # config.request_timeout            = 120 # Request timeout in seconds (default: 120)
+        # config.max_retries                = 3   # Max retries on transient network errors (default: 3)
+        # config.retry_interval             = 0.1 # Initial delay in seconds (default: 0.1)
+        # config.retry_backoff_factor       = 2   # Multiplier for subsequent retries (default: 2)
+        # config.retry_interval_randomness  = 0.5 # Jitter factor (default: 0.5)
+
+        # --- Logging Settings ---
+        # config.log_file   = '/logs/ruby_llm.log'
+        config.log_level  = :fatal # debug level can also be set to debug by setting RUBYLLM_DEBUG envar to true
+      end
+    end
+
+    def refresh_local_model_registry
+      if  AIA.config.refresh.nil?           ||
+          Integer(AIA.config.refresh).zero? ||
+          Date.today > (AIA.config.last_refresh + Integer(AIA.config.refresh))
+        RubyLLM.models.refresh!
+        AIA.config.last_refresh = Date.today
+        if AIA.config.config_file
+          AIA::Config.dump_config(AIA.config, AIA.config.config_file)
+        end
+      end
+    end
 
-        # 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)
+    def setup_chat_with_tools
+      begin
+        @chat = RubyLLM.chat(model: @model)
+      rescue => e
+        STDERR.puts "ERROR: #{e.message}"
+        exit 1
       end
 
-      @chat = RubyLLM.chat(model: model_info[:model])
+      if !AIA.config.tool_paths.empty? && !@chat.model.supports?(:function_calling)
+        STDERR.puts "ERROR: The model #{@model} does not support tools"
+        exit 1
+      end
 
       @tools = ObjectSpace.each_object(Class).select do |klass|
         klass < RubyLLM::Tool
       end
 
-      @chat.with_tools(*tools) unless tools.empty?
+      unless tools.empty?
+        @chat.with_tools(*tools)
+        AIA.config.tools = tools.map(&:name).join(', ')
+      end
     end
 
+    # TODO: Need to rethink this dispatcher pattern w/r/t RubyLLM's capabilities
+    #       This code was originally designed for AiClient
+    #
     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')
+      modes = @chat.model.modalities
+
+      # TODO: Need to consider how to handle multi-mode models
+      if modes.supports? :text_to_text
+        text_to_text(prompt)
+
+      elsif modes.supports? :image_to_text
         image_to_text(prompt)
-      elsif @model.downcase.include?('tts') || @model.downcase.include?('speech')
+      elsif modes.supports? :text_to_image
+        text_to_image(prompt)
+
+      elsif modes.supports? :text_to_audio
         text_to_audio(prompt)
-      elsif @model.downcase.include?('whisper') || @model.downcase.include?('transcription')
+      elsif modes.supports? :audio_to_text
         audio_to_text(prompt)
+
       else
-        text_to_text(prompt)
+        # TODO: what else can be done?
       end
     end
 
     def transcribe(audio_file)
-      @chat.ask("Transcribe this audio", with: { audio: audio_file })
+      @chat.ask("Transcribe this audio", with: audio_file)
     end
 
     def speak(text)
@@ -67,14 +134,6 @@ module AIA
       end
     end
 
-    def method_missing(method, *args, &block)
-      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
@@ -88,12 +147,18 @@ module AIA
 
         # Option 2: Force RubyLLM to create a new chat instance at the global level
         # This ensures any shared state is reset
-        model_info = extract_model_parts(@model)
+        @provider, @model = extract_model_parts.values
         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])
+
+        begin
+          @chat = RubyLLM.chat(model: @model)
+        rescue => e
+          STDERR.puts "ERROR: #{e.message}"
+          exit 1
+        end
 
         # Option 4: Call official clear_history method if it exists
         if @chat.respond_to?(:clear_history)
@@ -114,22 +179,33 @@ module AIA
       end
     end
 
+    def method_missing(method, *args, &block)
+      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
 
-    def extract_model_parts(model_string)
-      parts = model_string.split('/')
+    def extract_model_parts
+      parts = AIA.config.model.split('/')
       parts.map!(&:strip)
 
-      if parts.length > 1
-        provider = parts[0]
-        model = parts[1]
+      if 2 == parts.length
+        provider  = parts[0]
+        model     = parts[1]
+      elsif 1 == parts.length
+        provider  = nil # RubyLLM will figure it out from the model name
+        model     = parts[0]
       else
-        provider = nil # RubyLLM will figure it out from the model name
-        model = parts[0]
+        STDERR.puts "ERROR: malformed model name: #{AIA.config.model}"
+        exit 1
       end
 
       { provider: provider, model: model }
@@ -147,33 +223,62 @@ module AIA
       end
     end
 
+
+    #########################################
+    ## text
+
     def text_to_text(prompt)
       text_prompt = extract_text_prompt(prompt)
-      @chat.ask(text_prompt)
+      response  = if AIA.config.context_files.empty?
+                    @chat.ask(text_prompt)
+                  else
+                    @chat.ask(text_prompt, with: AIA.config.context_files)
+                  end
+
+      response.content
+    rescue => e
+      e.message
+    end
+
+
+    #########################################
+    ## Image
+
+    def extract_image_path(prompt)
+      if prompt.is_a?(String)
+        match = prompt.match(/\b[\w\/\.\-_]+?\.(jpg|jpeg|png|gif|webp)\b/i)
+        match ? match[0] : nil
+      elsif prompt.is_a?(Hash)
+        prompt[:image] || prompt[:image_path]
+      else
+        nil
+      end
     end
 
     def text_to_image(prompt)
       text_prompt = extract_text_prompt(prompt)
-      output_file = "#{Time.now.to_i}.png"
+      image_name  = extract_image_path(text_prompt)
 
       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}"
+        image = RubyLLM.paint(text_prompt, size: AIA.config.image_size)
+        if image_name
+          image_path = image.save(image_name)
+          "Image generated and saved to: #{image_path}"
+        else
+          "Image generated and available at: #{image.url}"
+        end
       rescue => e
         "Error generating image: #{e.message}"
       end
     end
 
     def image_to_text(prompt)
-      image_path = extract_image_path(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 })
+          @chat.ask(text_prompt, with: image_path).content
         rescue => e
           "Error analyzing image: #{e.message}"
         end
@@ -182,13 +287,21 @@ module AIA
       end
     end
 
+
+    #########################################
+    ## audio
+
+    def audio_file?(filepath)
+      filepath.to_s.downcase.end_with?('.mp3', '.wav', '.m4a', '.flac')
+    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
+        # TODO: 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}"
@@ -198,10 +311,22 @@ module AIA
     end
 
     def audio_to_text(prompt)
-      if prompt.is_a?(String) && File.exist?(prompt) &&
-         prompt.downcase.end_with?('.mp3', '.wav', '.m4a', '.flac')
+      text_prompt = extract_text_prompt(prompt)
+      text_prompt = 'Transcribe this audio' if text_prompt.nil? || text_prompt.empty?
+
+      # TODO: I don't think that "prompt" would ever be an audio filepath.
+      #       Check prompt to see if it is a PromptManager object that has context_files
+
+      if  prompt.is_a?(String) &&
+          File.exist?(prompt)  &&
+          audio_file?(prompt)
         begin
-          @chat.ask("Transcribe this audio", with: { audio: prompt })
+          response  = if AIA.config.context_files.empty?
+                        @chat.ask(text_prompt)
+                      else
+                        @chat.ask(text_prompt, with: AIA.config.context_files)
+                      end
+          response.content
         rescue => e
           "Error transcribing audio: #{e.message}"
         end
@@ -210,15 +335,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
-      elsif prompt.is_a?(Hash)
-        prompt[:image] || prompt[:image_path]
-      else
-        nil
-      end
-    end
   end
 end
+
+__END__

data/lib/aia/session.rb

@@ -123,16 +123,13 @@ module AIA
         prompt_text = "#{prompt_text}\n\nContext:\n#{context}"
       end
 
-      # Determine operation type
-      operation_type = @chat_processor.determine_operation_type(AIA.config.model)
-
       # Add initial user prompt to context *before* sending to AI
       @context_manager.add_to_context(role: 'user', content: prompt_text)
 
       # Process the initial prompt
       @ui_presenter.display_thinking_animation
       # Send the current context (which includes the user prompt)
-      response = @chat_processor.process_prompt(@context_manager.get_context, operation_type)
+      response = @chat_processor.process_prompt(@context_manager.get_context)
 
       # Add AI response to context
       @context_manager.add_to_context(role: 'assistant', content: response)
@@ -202,9 +199,8 @@ module AIA
             @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)
+            response = @chat_processor.process_prompt(@context_manager.get_context)
 
             # Add AI response to context
             @context_manager.add_to_context(role: 'assistant', content: response)
@@ -228,9 +224,8 @@ module AIA
 
             @context_manager.add_to_context(role: 'user', content: processed_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)
+            response = @chat_processor.process_prompt(@context_manager.get_context)
 
             @context_manager.add_to_context(role: 'assistant', content: response)
             @chat_processor.output_response(response)
@@ -273,7 +268,7 @@ module AIA
                begin
                  AIA.config.client = AIA::RubyLLMAdapter.new
                rescue => e
-                 SYSERR.puts "Error reinitializing client: #{e.message}"
+                 STDERR.puts "Error reinitializing client: #{e.message}"
                end
 
                @ui_presenter.display_info("Chat context cleared.")
@@ -292,9 +287,8 @@ module AIA
           @context_manager.add_to_context(role: 'user', content: processed_prompt)
           conversation = @context_manager.get_context
 
-          operation_type = @chat_processor.determine_operation_type(AIA.config.model)
           @ui_presenter.display_thinking_animation
-          response = @chat_processor.process_prompt(conversation, operation_type)
+          response = @chat_processor.process_prompt(conversation)
 
           @ui_presenter.display_ai_response(response)
           @context_manager.add_to_context(role: 'assistant', content: response)

data/lib/aia/utility.rb

@@ -1,23 +1,33 @@
 # lib/aia/utility.rb
 
+require 'word_wrapper'      # Pure ruby word wrapping
+
 module AIA
   class Utility
     class << self
       # Displays the AIA robot ASCII art
+      # Yes, its slightly frivolous but it does contain some
+      # useful configuration information.
       def robot
+        indent  = 18
+        spaces  = " "*indent
+        width   = TTY::Screen.width - indent - 2
+
         puts <<-ROBOT
 
        ,      ,
-       (\\____/) AI Assistant
+       (\\____/) AI Assistant (v#{AIA::VERSION}) is Online
         (_oo_)   #{AIA.config.model}
-         (O)      is Online
-       __||__    \\) using #{AIA.config.adapter}
-     [/______\\]  /
-    / \\__AI__/ \\/
+         (O)       using #{AIA.config.adapter} (v#{RubyLLM::VERSION})
+       __||__    \\) model db was last refreshed on
+     [/______\\]  /    #{AIA.config.last_refresh}
+    / \\__AI__/ \\/      #{AIA.config.tool_paths.empty? ? 'I forgot my toolbox' : 'I brought some tools'}
    /    /__\\
-  (\\   /____\\
-
+  (\\   /____\\   #{AIA.config.tool_paths.empty? ? '' : 'My Toolbox contains:'}
         ROBOT
+        if AIA.config.tools
+          puts WordWrapper::MinimumRaggedness.new(width, AIA.config.tools).wrap.split("\n").map{|s| spaces+s+"\n"}.join
+        end
       end
     end
   end

data/lib/aia.rb

@@ -5,7 +5,6 @@
 # provides an interface for interacting with AI models and managing prompts.
 
 require 'ruby_llm'
-
 require 'prompt_manager'
 
 require 'debug_me'
@@ -13,7 +12,14 @@ include DebugMe
 $DEBUG_ME = false
 DebugMeDefaultOptions[:skip1] = true
 
-require_relative 'extensions/openstruct_merge'
+require_relative 'extensions/openstruct_merge'    # adds self.merge self.get_value
+require_relative 'extensions/ruby_llm/modalities' # adds model.modalities.supports? :text-to-text etc.
+
+require_relative 'refinements/string.rb'        # adds #include_any? #include_all?
+
+
+
+
 require_relative 'aia/utility'
 require_relative 'aia/version'
 require_relative 'aia/config'
@@ -80,12 +86,21 @@ module AIA
     prompt_handler = PromptHandler.new
 
     # Initialize the appropriate client adapter based on configuration
-    @config.client = if @config.adapter == 'ruby_llm'
+    @config.client = if 'ruby_llm' == @config.adapter
                       RubyLLMAdapter.new
                     else
-                      AIClientAdapter.new
+                      # TODO: ?? some other LLM API wrapper
+                      STDERR.puts "ERROR: There is no adapter for #{@config.adapter}"
+                      exit 1
                     end
 
+    # There are two kinds of sessions: batch and chat
+    # A chat session is started when the --chat CLI option is used
+    # BUT its also possible to start a chat session with an initial prompt AND
+    # within that initial prompt there can be a workflow (aka pipeline)
+    # defined.  If that is the case, then the chat session will not start
+    # until the initial prompt has completed its workflow.
+
     session        = Session.new(prompt_handler)
 
     session.start

data/lib/extensions/ruby_llm/modalities.rb

@@ -0,0 +1,26 @@
+# lib/extensions/ruby_llm/modalities.rb
+# A models "modes" are often expressed in terms like:
+#   text-to-text
+#   text_to_audio
+#   audio to image
+#   image2image
+# This new supports? method tests the models modalities against
+# these common expressions
+
+class RubyLLM::Model::Modalities
+  def supports?(query_mode)
+    parts = query_mode
+              .to_s
+              .downcase
+              .split(/2|-to-| to |_to_/)
+              .map(&:strip)
+
+    if 2 == parts.size
+      input.include?(parts[0]) && output.include?(parts[1])
+    elsif 1 == parts.size
+      input.include?(parts[0]) || output.include?(parts[0])
+    else
+      false
+    end
+  end
+end

data/lib/refinements/string.rb

@@ -0,0 +1,16 @@
+# lib/aia_refinements/string.rb
+
+
+module Refinements
+  refine String do
+    def include_all?(substrings)
+      Array(substrings).all? { |substring| self.include?(substring) }
+    end
+    alias :all? :include_all?
+
+    def include_any?(substrings)
+      Array(substrings).any? { |substring| self.include?(substring) }
+    end
+    alias :any?  :include_any?
+  end
+end