aia 1.1.0 → 2.0.0.0.pre.alpha

data/lib/aia/adapter/modality_handlers.rb

@@ -1,167 +0,0 @@
-# lib/aia/adapter/modality_handlers.rb
-# frozen_string_literal: true
-
-require 'tempfile'
-
-module AIA
-  module Adapter
-    module ModalityHandlers
-      def transcribe(audio_file)
-        # Use the first model for transcription
-        first_model = @models.first
-        @chats[first_model].ask('Transcribe this audio', with: audio_file).content
-      end
-
-      def speak(_text)
-        # NOTE: RubyLLM doesn't have a direct text-to-speech feature
-        # This is a placeholder for a custom implementation or external service
-        tmpfile = Tempfile.new(['aia-tts-', '.mp3'])
-        begin
-          tmpfile.write('Mock TTS audio content')
-          tmpfile.close
-          speak_cmd = AIA.config.audio.speak_command
-          if system('which', speak_cmd, out: File::NULL, err: File::NULL)
-            system(speak_cmd, tmpfile.path)
-          end
-          "Audio generated successfully"
-        rescue StandardError => e
-          "Error generating audio: #{e.message}"
-        ensure
-          tmpfile.unlink
-        end
-      end
-
-      private
-
-      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
-
-      #########################################
-      ## text
-
-      def text_to_text_single(prompt, model_name)
-        chat_instance = @chats[model_name]
-        text_prompt = extract_text_prompt(prompt)
-
-        response = if AIA.config.context_files.empty?
-                     chat_instance.ask(text_prompt)
-                   else
-                     chat_instance.ask(text_prompt, with: AIA.config.context_files)
-                   end
-
-        # Return the full response object to preserve token information
-        response
-      rescue StandardError => e
-        # Tool crashes should not crash AIA - log and continue gracefully
-        handle_tool_crash(chat_instance, e)
-      end
-
-      #########################################
-      ## Image
-
-      def extract_image_path(prompt)
-        if prompt.is_a?(String)
-          match = prompt.match(%r{\b[\w/.\-_]+?\.(jpg|jpeg|png|gif|webp)\b}i)
-          match ? match[0] : nil
-        elsif prompt.is_a?(Hash)
-          prompt[:image] || prompt[:image_path]
-        end
-      end
-
-      def text_to_image_single(prompt, model_name)
-        text_prompt = extract_text_prompt(prompt)
-        image_name  = extract_image_path(text_prompt)
-
-        begin
-          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 StandardError => e
-          "Error generating image: #{e.message}"
-        end
-      end
-
-      def image_to_text_single(prompt, model_name)
-        image_path  = extract_image_path(prompt)
-        text_prompt = extract_text_prompt(prompt)
-
-        if image_path && File.exist?(image_path)
-          begin
-            @chats[model_name].ask(text_prompt, with: image_path).content
-          rescue StandardError => e
-            "Error analyzing image: #{e.message}"
-          end
-        else
-          text_to_text_single(prompt, model_name)
-        end
-      end
-
-      #########################################
-      ## audio
-
-      def audio_file?(filepath)
-        filepath.to_s.downcase.end_with?('.mp3', '.wav', '.m4a', '.flac')
-      end
-
-      def text_to_audio_single(prompt, model_name)
-        text_prompt = extract_text_prompt(prompt)
-
-        # NOTE: RubyLLM doesn't have a direct TTS feature
-        # TODO: This is a placeholder for a custom implementation
-        tmpfile = Tempfile.new(['aia-tts-', '.mp3'])
-        begin
-          tmpfile.write(text_prompt)
-          tmpfile.close
-          speak_cmd = AIA.config.audio.speak_command
-          if system('which', speak_cmd, out: File::NULL, err: File::NULL)
-            system(speak_cmd, tmpfile.path)
-          end
-          "Audio generated successfully"
-        rescue StandardError => e
-          "Error generating audio: #{e.message}"
-        ensure
-          tmpfile.unlink
-        end
-      end
-
-      def audio_to_text_single(prompt, model_name)
-        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
-            response = if AIA.config.context_files.empty?
-                         @chats[model_name].ask(text_prompt)
-                       else
-                         @chats[model_name].ask(text_prompt, with: AIA.config.context_files)
-                       end
-            response.content
-          rescue StandardError => e
-            "Error transcribing audio: #{e.message}"
-          end
-        else
-          # Fall back to regular chat if no valid audio file is found
-          text_to_text_single(prompt, model_name)
-        end
-      end
-    end
-  end
-end

data/lib/aia/adapter/model_registry.rb

@@ -1,81 +0,0 @@
-# lib/aia/adapter/model_registry.rb
-# frozen_string_literal: true
-
-require 'fileutils'
-require 'json'
-
-module AIA
-  module Adapter
-    class ModelRegistry
-      def refresh
-        return if models_json_path.nil? # Skip if no aia_dir configured
-
-        # On first use, copy the bundled models.json from RubyLLM (no API calls)
-        copy_bundled_models_to_local unless File.exist?(models_json_path)
-
-        # Point RubyLLM at our local registry file for all model lookups
-        RubyLLM.config.model_registry_file = models_json_path
-
-        # Coerce refresh_days to integer (env vars come as strings)
-        refresh_days = AIA.config.registry.refresh
-        refresh_days = refresh_days.to_i if refresh_days.respond_to?(:to_i)
-        refresh_days ||= 7 # Default to 7 days if nil
-
-        # If refresh is disabled (0), just use the local file as-is
-        return if refresh_days.zero?
-
-        # Only refresh from provider APIs when enough days have elapsed
-        last_refresh = models_last_refresh
-        return unless last_refresh.nil? || Date.today > (last_refresh + refresh_days)
-
-        # Refresh models from provider APIs and models.dev
-        RubyLLM.models.refresh!
-
-        # Save refreshed models to our local JSON file
-        save_models_to_json
-      end
-
-      def models_json_path
-        aia_dir = AIA.config.paths&.aia_dir
-        return nil if aia_dir.nil?
-
-        File.join(File.expand_path(aia_dir), 'models.json')
-      end
-
-      # Returns the last refresh date based on models.json modification time
-      def models_last_refresh
-        path = models_json_path
-        return nil if path.nil? || !File.exist?(path)
-
-        File.mtime(path).to_date
-      end
-
-      def copy_bundled_models_to_local
-        aia_dir = File.expand_path(AIA.config.paths.aia_dir)
-        FileUtils.mkdir_p(aia_dir)
-
-        # RubyLLM.config.model_registry_file points to the gem's bundled models.json
-        # before we redirect it to our local copy
-        bundled_path = RubyLLM.config.model_registry_file
-
-        if bundled_path && File.exist?(bundled_path)
-          FileUtils.cp(bundled_path, models_json_path)
-        else
-          # Fallback: save whatever RubyLLM has loaded from its bundled data
-          save_models_to_json
-        end
-      end
-
-      def save_models_to_json
-        return if models_json_path.nil?
-
-        aia_dir = File.expand_path(AIA.config.paths.aia_dir)
-        FileUtils.mkdir_p(aia_dir)
-
-        models_data = RubyLLM.models.all.map(&:to_h)
-
-        File.write(models_json_path, JSON.pretty_generate(models_data))
-      end
-    end
-  end
-end

data/lib/aia/adapter/multi_model_chat.rb

@@ -1,218 +0,0 @@
-# lib/aia/adapter/multi_model_chat.rb
-# frozen_string_literal: true
-
-require 'async'
-
-module AIA
-  module Adapter
-    module MultiModelChat
-      # Helper class to carry multi-model response with metrics
-      class MultiModelResponse
-        attr_reader :content, :metrics_list
-
-        def initialize(content, metrics_list)
-          @content = content
-          @metrics_list = metrics_list
-        end
-
-        def multi_model?
-          true
-        end
-      end
-
-      # Prepend role content to prompt for a specific model (ADR-005)
-      def prepend_model_role(prompt, internal_id)
-        # Get model spec to find role
-        spec = get_model_spec(internal_id)
-        return prompt unless spec && spec[:role]
-
-        # Get role content using PromptHandler
-        prompt_handler = AIA::PromptHandler.new
-        role_content = prompt_handler.load_role_for_model(spec, AIA.config.prompts.role)
-
-        return prompt unless role_content
-
-        # Prepend role to prompt based on prompt type
-        if prompt.is_a?(String)
-          "#{role_content}\n\n#{prompt}"
-        elsif prompt.is_a?(Array)
-          prepend_role_to_conversation(prompt, role_content)
-        else
-          prompt
-        end
-      end
-
-      def prepend_role_to_conversation(conversation, role_content)
-        # Find the first user message and prepend role
-        modified = conversation.dup
-        first_user_index = modified.find_index { |msg| msg[:role] == "user" || msg["role"] == "user" }
-
-        if first_user_index
-          msg = modified[first_user_index].dup
-          content_key = msg.key?(:content) ? :content : "content"
-
-          msg[content_key] = "#{role_content}\n\n#{msg[content_key]}"
-          modified[first_user_index] = msg
-        end
-
-        modified
-      end
-
-      def multi_model_chat(prompt_or_contexts)
-        results = {}
-
-        # Check if we're receiving per-model contexts (Hash) or shared prompt (String/Array) - ADR-002 revised
-        per_model_contexts = prompt_or_contexts.is_a?(Hash) &&
-                             prompt_or_contexts.keys.all? { |k| @models.include?(k) }
-
-        Async do |task|
-          @models.each do |internal_id|
-            task.async do
-              begin
-                # Use model-specific context if available, otherwise shared prompt
-                prompt = if per_model_contexts
-                           prompt_or_contexts[internal_id]
-                         else
-                           prompt_or_contexts
-                         end
-
-                # Add per-model role if specified (ADR-005)
-                prompt = prepend_model_role(prompt, internal_id)
-
-                result = single_model_chat(prompt, internal_id)
-                results[internal_id] = result
-              rescue StandardError => e
-                results[internal_id] = "Error with #{internal_id}: #{e.message}"
-              end
-            end
-          end
-        end
-
-        # Format and return results from all models
-        format_multi_model_results(results)
-      end
-
-      def format_multi_model_results(results)
-        if should_use_consensus_mode?
-          generate_consensus_response(results)
-        else
-          format_individual_responses(results)
-        end
-      end
-
-      def should_use_consensus_mode?
-        AIA.config.flags.consensus == true
-      end
-
-      def generate_consensus_response(results)
-        primary_model = @models.first
-        primary_chat = @chats[primary_model]
-
-        consensus_prompt = build_consensus_prompt(results)
-
-        begin
-          consensus_result = primary_chat.ask(consensus_prompt).content
-          "from: #{primary_model}\n#{consensus_result}"
-        rescue StandardError => e
-          "Error generating consensus: #{e.message}\n\n" + format_individual_responses(results)
-        end
-      end
-
-      def build_consensus_prompt(results)
-        prompt_parts = []
-        prompt_parts << "You are tasked with creating a consensus response based on multiple AI model responses to the same query."
-        prompt_parts << "Please analyze the following responses and provide a unified, comprehensive answer that:"
-        prompt_parts << "- Incorporates the best insights from all models"
-        prompt_parts << "- Resolves any contradictions with clear reasoning"
-        prompt_parts << "- Provides additional context or clarification when helpful"
-        prompt_parts << "- Maintains accuracy and avoids speculation"
-        prompt_parts << ""
-        prompt_parts << "Model responses:"
-        prompt_parts << ""
-
-        results.each do |model_name, result|
-          content = if result.respond_to?(:content)
-                      result.content
-                    else
-                      result.to_s
-                    end
-          next if content.start_with?("Error with")
-          prompt_parts << "#{model_name}:"
-          prompt_parts << content
-          prompt_parts << ""
-        end
-
-        prompt_parts << "Please provide your consensus response:"
-        prompt_parts.join("\n")
-      end
-
-      def format_individual_responses(results)
-        has_metrics = results.values.any? { |r| r.respond_to?(:input_tokens) && r.respond_to?(:output_tokens) }
-
-        if has_metrics
-          format_multi_model_with_metrics(results)
-        else
-          output = []
-          results.each do |internal_id, result|
-            spec = get_model_spec(internal_id)
-            display_name = format_model_display_name(spec)
-
-            output << "from: #{display_name}"
-            content = if result.respond_to?(:content)
-                        result.content
-                      else
-                        result.to_s
-                      end
-            output << content
-            output << "" # Add blank line between results
-          end
-          output.join("\n")
-        end
-      end
-
-      # Format display name with instance number and role (ADR-005)
-      def format_model_display_name(spec)
-        return spec unless spec.is_a?(Hash)
-
-        model_name = spec[:model]
-        instance = spec[:instance]
-        role = spec[:role]
-
-        display = if instance > 1
-                    "#{model_name} ##{instance}"
-                  else
-                    model_name
-                  end
-
-        display += " (#{role})" if role
-
-        display
-      end
-
-      def format_multi_model_with_metrics(results)
-        formatted_content = []
-        metrics_data = []
-
-        results.each do |internal_id, result|
-          spec = get_model_spec(internal_id)
-          display_name = format_model_display_name(spec)
-
-          formatted_content << "from: #{display_name}"
-          content = result.respond_to?(:content) ? result.content : result.to_s
-          formatted_content << content
-          formatted_content << ""
-
-          actual_model = spec ? spec[:model] : internal_id
-          metrics_data << {
-            model_id: actual_model,
-            display_name: display_name,
-            input_tokens: result.respond_to?(:input_tokens) ? result.input_tokens : nil,
-            output_tokens: result.respond_to?(:output_tokens) ? result.output_tokens : nil
-          }
-        end
-
-        MultiModelResponse.new(formatted_content.join("\n"), metrics_data)
-      end
-    end
-  end
-end

data/lib/aia/adapter/provider_configurator.rb

@@ -1,59 +0,0 @@
-# lib/aia/adapter/provider_configurator.rb
-# frozen_string_literal: true
-
-module AIA
-  module Adapter
-    class ProviderConfigurator
-      def self.configure
-        # TODO: Add some of these configuration items to AIA.config
-        # Note: RubyLLM supports specific providers. Use provider prefix (e.g., "xai/grok-beta")
-        # for providers not directly configured here.
-        RubyLLM.configure do |config|
-          config.anthropic_api_key  = ENV.fetch('ANTHROPIC_API_KEY', nil)
-          config.deepseek_api_key   = ENV.fetch('DEEPSEEK_API_KEY', nil)
-          config.gemini_api_key     = ENV.fetch('GEMINI_API_KEY', nil)
-          config.gpustack_api_key   = ENV.fetch('GPUSTACK_API_KEY', nil)
-          config.mistral_api_key    = ENV.fetch('MISTRAL_API_KEY', nil)
-          config.openrouter_api_key = ENV.fetch('OPEN_ROUTER_API_KEY', nil)
-          config.perplexity_api_key = ENV.fetch('PERPLEXITY_API_KEY', nil)
-
-          # These providers require a little something extra
-          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.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)
-
-          # Ollama is based upon the OpenAI API so it needs to over-ride a few things
-          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.
-          # For osaurus: Use model name prefix "osaurus/" and set OSAURUS_API_BASE env var
-          # For LM Studio: Use model name prefix "lms/" and set LMS_API_BASE env var
-          config.openai_api_base = ENV.fetch('OPENAI_API_BASE', nil) # e.g., "https://your-azure.openai.azure.com"
-
-          # --- 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)
-
-          # Configure RubyLLM logger from centralized LoggerManager
-          config.log_level = LoggerManager.llm_log_level_symbol
-        end
-
-        # Configure RubyLLM's logger output destination
-        LoggerManager.configure_llm_logger
-
-        # Configure RubyLLM::MCP's logger early, before any MCP operations
-        # This ensures all MCP debug/info logs go to the configured log file
-        LoggerManager.configure_mcp_logger
-      end
-    end
-  end
-end

data/lib/aia/adapter/tool_filter.rb

@@ -1,85 +0,0 @@
-# lib/aia/adapter/tool_filter.rb
-# frozen_string_literal: true
-
-require 'set'
-
-module AIA
-  module Adapter
-    class ToolFilter
-      def self.filter_allowed(tools)
-        allowed = AIA.config.tools.allowed
-        return tools if allowed.nil? || allowed.empty?
-
-        allowed_list = Array(allowed).map(&:strip)
-
-        tools.select do |tool|
-          tool_name = tool.respond_to?(:name) ? tool.name : tool.class.name
-          allowed_list.any? { |allowed_pattern| tool_name.include?(allowed_pattern) }
-        end
-      end
-
-      def self.filter_rejected(tools)
-        rejected = AIA.config.tools.rejected
-        return tools if rejected.nil? || rejected.empty?
-
-        rejected_list = Array(rejected).map(&:strip)
-
-        tools.reject do |tool|
-          tool_name = tool.respond_to?(:name) ? tool.name : tool.class.name
-          rejected_list.any? { |rejected_pattern| tool_name.include?(rejected_pattern) }
-        end
-      end
-
-      def self.detect_conflicts
-        allowed  = AIA.config.tools.allowed
-        rejected = AIA.config.tools.rejected
-        return [] if allowed.nil? || allowed.empty? || rejected.nil? || rejected.empty?
-
-        allowed_list  = Array(allowed).map(&:strip)
-        rejected_list = Array(rejected).map(&:strip)
-
-        conflicts = allowed_list & rejected_list
-        return [] if conflicts.empty?
-
-        logger = LoggerManager.aia_logger
-        conflicts.each do |pattern|
-          msg = "Tool pattern '#{pattern}' appears in both --allowed-tools and --rejected-tools. Rejected takes precedence."
-          logger.warn(msg)
-          warn "WARNING: #{msg}"
-        end
-
-        conflicts
-      end
-
-      def self.drop_duplicates(tools)
-        seen_names = Set.new
-        original_size = tools.size
-
-        logger = LoggerManager.aia_logger
-        logger.debug("Checking tools for duplicates", tool_count: original_size)
-
-        result = tools.select do |tool|
-          tool_name = tool.name
-          if seen_names.include?(tool_name)
-            logger.warn("Duplicate tool detected - keeping first occurrence only", tool: tool_name)
-            warn "WARNING: Duplicate tool name detected: '#{tool_name}'. Only the first occurrence will be used."
-            false
-          else
-            seen_names.add(tool_name)
-            true
-          end
-        end
-
-        removed_count = original_size - result.size
-        if removed_count > 0
-          logger.info("Removed duplicate tools", removed_count: removed_count, remaining_count: result.size)
-          warn "Removed #{removed_count} duplicate tools"
-        else
-          logger.debug("No duplicate tools found")
-        end
-
-        result
-      end
-    end
-  end
-end

data/lib/aia/adapter/tool_loader.rb

@@ -1,90 +0,0 @@
-# lib/aia/adapter/tool_loader.rb
-# frozen_string_literal: true
-
-module AIA
-  module Adapter
-    class ToolLoader
-      def initialize(mcp_connector)
-        @mcp_connector = mcp_connector
-      end
-
-      def load_tools
-        tools = []
-
-        tools += scan_local_tools
-        @mcp_connector.support_mcp(tools)
-        tools
-      end
-
-      def scan_local_tools
-        tools = []
-
-        # First, load any required libraries specified in config
-        load_require_libs
-
-        # Then, load tool files from tools.paths
-        load_tool_files
-
-        # Now scan ObjectSpace for RubyLLM::Tool subclasses
-        tool_classes = ObjectSpace.each_object(Class).select do |klass|
-          next false unless klass < RubyLLM::Tool
-
-          # Filter out tools that can't be instantiated without arguments
-          # RubyLLM calls tool.new without args, so we must verify each tool works
-          begin
-            klass.new
-            true
-          rescue ArgumentError, LoadError, StandardError
-            # Skip tools that require arguments or have missing dependencies
-            false
-          end
-        end
-
-        tools + tool_classes
-      end
-
-      private
-
-      def load_require_libs
-        require_libs = AIA.config.require_libs
-        return if require_libs.nil? || require_libs.empty?
-
-        require_libs.each do |lib|
-          begin
-            # Activate gem and add to load path (bypasses Bundler's restrictions)
-            GemActivator.activate_gem_for_require(lib)
-
-            require lib
-
-            # After requiring, trigger tool loading if the library supports it
-            # This handles gems like shared_tools that use Zeitwerk lazy loading
-            GemActivator.trigger_tool_loading(lib)
-          rescue LoadError => e
-            warn "Warning: Failed to require library '#{lib}': #{e.message}"
-            warn "Hint: Make sure the gem is installed: gem install #{lib}"
-          rescue StandardError => e
-            warn "Warning: Error in library '#{lib}': #{e.class} - #{e.message}"
-          end
-        end
-      end
-
-      def load_tool_files
-        paths = AIA.config.tools&.paths
-        return if paths.nil? || paths.empty?
-
-        paths.each do |path|
-          expanded_path = File.expand_path(path)
-          if File.exist?(expanded_path)
-            begin
-              require expanded_path
-            rescue LoadError, StandardError => e
-              warn "Warning: Failed to load tool file '#{path}': #{e.message}"
-            end
-          else
-            warn "Warning: Tool file not found: #{path}"
-          end
-        end
-      end
-    end
-  end
-end