aia 1.1.1 → 2.0.0.0.pre.alpha

data/lib/aia/adapter/chat_execution.rb

@@ -1,242 +0,0 @@
-# lib/aia/adapter/chat_execution.rb
-# frozen_string_literal: true
-
-module AIA
-  module Adapter
-    module ChatExecution
-      def chat(prompt)
-        if @models.size == 1
-          single_model_chat(prompt, @models.first)
-        else
-          multi_model_chat(prompt)
-        end
-      end
-
-      def single_model_chat(prompt, internal_id)
-        chat_instance = @chats[internal_id]
-        modes = chat_instance.model.modalities
-
-        # TODO: Need to consider how to handle multi-mode models
-        if modes.text_to_text?
-          text_to_text_single(prompt, internal_id)
-        elsif modes.image_to_text?
-          image_to_text_single(prompt, internal_id)
-        elsif modes.text_to_image?
-          text_to_image_single(prompt, internal_id)
-        elsif modes.text_to_audio?
-          text_to_audio_single(prompt, internal_id)
-        elsif modes.audio_to_text?
-          audio_to_text_single(prompt, internal_id)
-        else
-          # TODO: what else can be done?
-          "Error: No matching modality for model #{internal_id}"
-        end
-      end
-
-      # Clear the chat context/history
-      # Needed for the /clear and /restore directives
-      # Simplified with ADR-002: Each model has isolated context, no global state to manage
-      def clear_context
-        old_chats = @chats.dup
-        new_chats = {}
-
-        @models.each do |model_name|
-          begin
-            # Get the isolated context for this model
-            context = @contexts[model_name]
-            actual_model, provider = extract_model_and_provider(model_name)
-
-            # Create a fresh chat instance from the same isolated context
-            chat = if provider
-                     context.chat(model: actual_model, provider: provider, assume_model_exists: true)
-                   else
-                     context.chat(model: actual_model)
-                   end
-
-            # Re-add tools if they were previously loaded
-            if @tools && !@tools.empty? && chat.model&.supports_functions?
-              chat.with_tools(*@tools)
-            end
-
-            new_chats[model_name] = chat
-          rescue StandardError => e
-            # If recreation fails, keep the old chat but clear its messages
-            warn "Warning: Could not recreate chat for #{model_name}: #{e.message}. Clearing existing chat."
-            chat = old_chats[model_name]
-            if chat&.instance_variable_defined?(:@messages)
-              chat.instance_variable_set(:@messages, [])
-            end
-            chat.clear_history if chat&.respond_to?(:clear_history)
-            new_chats[model_name] = chat
-          end
-        end
-
-        @chats = new_chats
-        'Chat context successfully cleared.'
-      rescue StandardError => e
-        "Error clearing chat context: #{e.message}"
-      end
-
-      def setup_chats_with_tools
-        valid_chats = {}
-        valid_contexts = {}
-        valid_specs = []
-        failed_models = []
-
-        @model_specs.each do |spec|
-          model_name = spec[:model]          # Actual model name (e.g., "gpt-4o")
-          internal_id = spec[:internal_id]   # Key for storage (e.g., "gpt-4o#1", "gpt-4o#2")
-
-          begin
-            # Create isolated context for this model to prevent cross-talk (ADR-002)
-            context = create_isolated_context_for_model(model_name)
-
-            # Determine provider and actual model name
-            actual_model, provider = extract_model_and_provider(model_name)
-
-            # Validate LM Studio models
-            if model_name.start_with?('lms/')
-              lms_api_base = ENV.fetch('LMS_API_BASE', 'http://localhost:1234/v1')
-              validate_lms_model!(actual_model, lms_api_base)
-            end
-
-            # Create chat using isolated context
-            chat = if provider
-                     context.chat(model: actual_model, provider: provider, assume_model_exists: true)
-                   else
-                     context.chat(model: actual_model)
-                   end
-
-            valid_chats[internal_id] = chat
-            valid_contexts[internal_id] = context
-            valid_specs << spec
-          rescue StandardError => e
-            failed_models << "#{internal_id}: #{e.message}"
-          end
-        end
-
-        # Report failed models but continue with valid ones
-        unless failed_models.empty?
-          warn "\nFailed to initialize the following models:"
-          failed_models.each { |failure| warn "   - #{failure}" }
-          logger = LoggerManager.aia_logger
-          failed_models.each { |failure| logger.error("Model initialization failed: #{failure}") }
-        end
-
-        # If no models initialized successfully, exit
-        if valid_chats.empty?
-          warn "\nNo valid models could be initialized. Exiting."
-          warn "\nAvailable models can be listed with: bin/aia --help models"
-          exit 1
-        end
-
-        @chats = valid_chats
-        @contexts = valid_contexts
-        @model_specs = valid_specs
-        @models = valid_chats.keys
-
-        # Report successful models
-        if failed_models.any?
-          warn "\nSuccessfully initialized: #{@models.join(', ')}"
-        end
-
-        # Use the first chat to determine tool support (assuming all models have similar tool support)
-        first_chat = @chats.values.first
-        return unless first_chat&.model&.supports_functions?
-
-        load_tools_lazy_mcp_support_only_when_needed
-
-        @chats.each_value do |chat|
-          chat.with_tools(*tools) unless tools.empty?
-        end
-      end
-
-      # Create an isolated RubyLLM::Context for a model to prevent cross-talk (ADR-002)
-      # Each model gets its own context with provider-specific configuration
-      def create_isolated_context_for_model(model_name)
-        config = RubyLLM.config.dup
-
-        # Apply provider-specific configuration
-        if model_name.start_with?('lms/')
-          config.openai_api_base = ENV.fetch('LMS_API_BASE', 'http://localhost:1234/v1')
-          config.openai_api_key = 'dummy' # Local servers don't need a real API key
-        elsif model_name.start_with?('osaurus/')
-          config.openai_api_base = ENV.fetch('OSAURUS_API_BASE', 'http://localhost:11434/v1')
-          config.openai_api_key = 'dummy' # Local servers don't need a real API key
-        end
-
-        RubyLLM::Context.new(config)
-      end
-
-      # Extract the actual model name and provider from the prefixed model_name
-      # Returns: [actual_model, provider] where provider may be nil for auto-detection
-      def extract_model_and_provider(model_name)
-        if model_name.start_with?('ollama/')
-          [model_name.sub('ollama/', ''), 'ollama']
-        elsif model_name.start_with?('lms/') || model_name.start_with?('osaurus/')
-          [model_name.sub(%r{^(lms|osaurus)/}, ''), 'openai']
-        else
-          [model_name, nil] # Let RubyLLM auto-detect provider
-        end
-      end
-
-      def validate_lms_model!(model_name, api_base)
-        require 'net/http'
-        require 'json'
-
-        # Build the /v1/models endpoint URL
-        uri = URI("#{api_base.gsub(%r{/v1/?$}, '')}/v1/models")
-
-        begin
-          response = Net::HTTP.get_response(uri)
-
-          unless response.is_a?(Net::HTTPSuccess)
-            raise "Cannot connect to LM Studio at #{api_base}. Is LM Studio running?"
-          end
-
-          data = JSON.parse(response.body)
-          available_models = data['data']&.map { |m| m['id'] } || []
-
-          unless available_models.include?(model_name)
-            error_msg = "'#{model_name}' is not a valid LM Studio model.\n\n"
-            if available_models.empty?
-              error_msg += "No models are currently loaded in LM Studio.\n"
-              error_msg += "Please load a model in LM Studio first."
-            else
-              error_msg += "Available LM Studio models:\n"
-              available_models.each { |m| error_msg += "  - lms/#{m}\n" }
-            end
-            raise error_msg
-          end
-        rescue JSON::ParserError => e
-          raise "Invalid response from LM Studio at #{api_base}: #{e.message}"
-        rescue StandardError => e
-          # Re-raise our custom error messages, wrap others
-          raise if e.message.include?("not a valid LM Studio") || e.message.include?("Cannot connect")
-          raise "Error connecting to LM Studio: #{e.message}"
-        end
-      end
-
-      private
-
-      def load_tools_lazy_mcp_support_only_when_needed
-        mcp_connector = McpConnector.new
-        tool_loader = ToolLoader.new(mcp_connector)
-
-        @tools = tool_loader.load_tools
-        ToolFilter.detect_conflicts
-        @tools = ToolFilter.filter_allowed(@tools)
-        @tools = ToolFilter.filter_rejected(@tools)
-        @tools = ToolFilter.drop_duplicates(@tools)
-
-        if tools.empty?
-          AIA.config.tool_names = ''
-          AIA.config.loaded_tools = []
-        else
-          AIA.config.tool_names = @tools.map(&:name).join(', ')
-          AIA.config.loaded_tools = @tools
-        end
-      end
-    end
-  end
-end

data/lib/aia/adapter/error_handler.rb

@@ -1,68 +0,0 @@
-# lib/aia/adapter/error_handler.rb
-# frozen_string_literal: true
-
-module AIA
-  module Adapter
-    module ErrorHandler
-      # Handles tool execution crashes gracefully
-      # Logs error with short traceback, repairs conversation, and returns error message
-      def handle_tool_crash(chat_instance, exception)
-        error_msg = "Tool error: #{exception.class} - #{exception.message}"
-
-        # Log error with short traceback (first 5 lines)
-        warn "\n  #{error_msg}"
-        if exception.backtrace
-          short_trace = exception.backtrace.first(5).map { |line| "   #{line}" }.join("\n")
-          warn short_trace
-        end
-        warn "" # blank line for readability
-
-        # Repair incomplete tool calls to maintain conversation integrity
-        repair_incomplete_tool_calls(chat_instance, error_msg)
-
-        # Return error message so conversation can continue
-        error_msg
-      end
-
-      # Repairs conversation history when a tool call fails (timeout, error, etc.)
-      # When an MCP tool times out, the conversation gets into an invalid state:
-      # - Assistant message with tool_calls was added to history
-      # - But no tool result message was added (because the tool failed)
-      # - The API requires tool results for each tool_call_id
-      # This method adds synthetic error tool results to fix the conversation.
-      def repair_incomplete_tool_calls(chat_instance, error_message)
-        return unless chat_instance.respond_to?(:messages)
-
-        messages = chat_instance.messages
-        return if messages.empty?
-
-        # Find the last assistant message that has tool_calls
-        last_assistant_with_tools = messages.reverse.find do |msg|
-          msg.role == :assistant && msg.respond_to?(:tool_calls) && msg.tool_calls&.any?
-        end
-
-        return unless last_assistant_with_tools
-
-        # Get the tool_call_ids that need results
-        tool_call_ids = last_assistant_with_tools.tool_calls.keys
-
-        # Check which tool_call_ids already have results
-        existing_tool_results = messages.select { |m| m.role == :tool }.map(&:tool_call_id).compact
-
-        # Add synthetic error results for any missing tool_call_ids
-        tool_call_ids.each do |tool_call_id|
-          next if existing_tool_results.include?(tool_call_id.to_s) || existing_tool_results.include?(tool_call_id)
-
-          # Add a synthetic tool result with the error message
-          chat_instance.add_message(
-            role: :tool,
-            content: "Error: #{error_message}",
-            tool_call_id: tool_call_id
-          )
-        end
-      rescue StandardError
-        # Don't let repair failures cascade
-      end
-    end
-  end
-end

data/lib/aia/adapter/gem_activator.rb

@@ -1,57 +0,0 @@
-# lib/aia/adapter/gem_activator.rb
-# frozen_string_literal: true
-
-module AIA
-  module Adapter
-    class GemActivator
-      # Activate a gem and add its lib path to $LOAD_PATH
-      # This bypasses Bundler's restrictions on loading non-bundled gems
-      def self.activate_gem_for_require(lib)
-        return if Gem.try_activate(lib)
-
-        gem_path = find_gem_path(lib)
-        if gem_path
-          lib_path = File.join(gem_path, 'lib')
-          $LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)
-        end
-      end
-
-      # Find gem path by searching gem directories directly
-      # This bypasses Bundler's restrictions
-      def self.find_gem_path(gem_name)
-        gem_dirs = Gem.path.flat_map do |base|
-          gems_dir = File.join(base, 'gems')
-          next [] unless File.directory?(gems_dir)
-
-          Dir.glob(File.join(gems_dir, "#{gem_name}-*")).select do |path|
-            File.directory?(path) && File.basename(path).match?(/^#{Regexp.escape(gem_name)}-[\d.]+/)
-          end
-        end
-
-        # Return the most recent version
-        gem_dirs.sort.last
-      end
-
-      # Some tool libraries use lazy loading (e.g., Zeitwerk) and need explicit
-      # triggering to load tool classes into ObjectSpace
-      def self.trigger_tool_loading(lib)
-        # Convert lib name to constant (e.g., 'shared_tools' -> SharedTools)
-        const_name = lib.split(/[_-]/).map(&:capitalize).join
-
-        begin
-          mod = Object.const_get(const_name)
-
-          # Try common methods that libraries use to load tools
-          if mod.respond_to?(:load_all_tools)
-            mod.load_all_tools
-          elsif mod.respond_to?(:tools)
-            # Calling .tools often triggers lazy loading
-            mod.tools
-          end
-        rescue NameError
-          # Constant doesn't exist, library might use different naming
-        end
-      end
-    end
-  end
-end

data/lib/aia/adapter/mcp_connector.rb

@@ -1,274 +0,0 @@
-# lib/aia/adapter/mcp_connector.rb
-# frozen_string_literal: true
-
-require 'simple_flow'
-
-module AIA
-  module Adapter
-    class McpConnector
-      # Default timeout for MCP client initialization (in milliseconds)
-      # RubyLLM::MCP expects timeout in milliseconds (e.g., 8000 = 8 seconds)
-      # Using a short timeout to prevent slow servers from blocking startup
-      MCP_DEFAULT_TIMEOUT = 8_000  # 8 seconds (same as RubyLLM::MCP default)
-
-      def support_mcp(tools)
-        if AIA.config.flags.no_mcp
-          logger.debug("MCP processing bypassed via --no-mcp flag")
-          return
-        end
-
-        if AIA.config.mcp_servers.nil? || AIA.config.mcp_servers.empty?
-          logger.debug("No MCP servers configured, skipping MCP setup")
-          return
-        end
-
-        # Initialize tracking (kept for compatibility with Utility.robot)
-        AIA.config.connected_mcp_servers = []
-        AIA.config.failed_mcp_servers = []
-
-        servers = filter_mcp_servers(AIA.config.mcp_servers)
-        server_names = servers.map { |s| s[:name] || s['name'] }.compact
-
-        logger.info("Starting parallel MCP connection", server_count: servers.size, servers: server_names)
-        $stderr.puts "MCP: Connecting to #{server_names.join(', ')}..."
-        $stderr.flush
-
-        LoggerManager.configure_mcp_logger
-
-        # Build steps array first (outside the block to preserve self reference)
-        # Each step is a [name, callable] pair for parallel execution
-        connector = self
-        steps = servers.map do |server|
-          name = (server[:name] || server['name']).to_sym
-          logger.debug("Building connection step", server: name)
-          [name, connector.send(:build_mcp_connection_step, server)]
-        end
-
-        # Build parallel pipeline - each server is independent (depends_on: :none)
-        # All servers will connect concurrently using fiber-based async
-        logger.debug("Creating SimpleFlow pipeline", step_count: steps.size)
-        pipeline = SimpleFlow::Pipeline.new(concurrency: :async) do
-          steps.each do |name, callable|
-            step name, callable, depends_on: :none
-          end
-        end
-
-        # Execute all connections in parallel
-        start_time = Time.now
-        initial_result = SimpleFlow::Result.new({ tools: [] })
-        final_result = pipeline.call_parallel(initial_result)
-        elapsed = Time.now - start_time
-
-        logger.info("Parallel MCP connection completed", elapsed_seconds: elapsed.round(2))
-
-        # Extract results and populate config arrays for compatibility
-        extract_mcp_results(final_result, tools)
-      end
-
-      def filter_mcp_servers(servers)
-        use_list = Array(AIA.config.mcp_use)
-        skip_list = Array(AIA.config.mcp_skip)
-
-        if !use_list.empty?
-          servers = servers.select do |server|
-            name = server[:name] || server['name']
-            use_list.include?(name)
-          end
-          logger.info("MCP servers filtered by --mcp-use", use: use_list, remaining: servers.size)
-        elsif !skip_list.empty?
-          servers = servers.reject do |server|
-            name = server[:name] || server['name']
-            skip_list.include?(name)
-          end
-          logger.info("MCP servers filtered by --mcp-skip", skip: skip_list, remaining: servers.size)
-        end
-
-        servers
-      end
-
-      private
-
-      def logger
-        @logger ||= LoggerManager.aia_logger
-      end
-
-      def build_mcp_connection_step(server)
-        # Capture logger in closure for use within the lambda
-        log = logger
-
-        ->(result) {
-          name = server[:name] || server['name']
-          start_time = Time.now
-
-          begin
-            log.debug("Registering MCP client", server: name)
-
-            # Register client with RubyLLM::MCP
-            client = register_single_mcp_client(server)
-
-            log.debug("Starting client connection", server: name)
-
-            # Start and verify connection
-            client.start
-            caps = client.capabilities
-            has_capabilities = caps && (caps.is_a?(Hash) ? !caps.empty? : caps)
-
-            elapsed = Time.now - start_time
-
-            if client.alive? && has_capabilities
-              # Success - get tools and record in context
-              tools = begin
-                client.tools
-              rescue StandardError => tool_err
-                log.warn("Failed to retrieve tools", server: name, error: tool_err.message)
-                []
-              end
-
-              tool_names = tools.map { |t| t.respond_to?(:name) ? t.name : t.to_s }
-              log.info("Connected successfully", server: name, elapsed_seconds: elapsed.round(2), tool_count: tools.size)
-              log.debug("Available tools", server: name, tools: tool_names)
-
-              result
-                .with_context(name.to_sym, { status: :connected, tools: tools })
-                .continue(result.value)
-            else
-              # Connection issue - determine specific error
-              error = determine_mcp_connection_error(client, caps)
-              log.warn("Connection failed", server: name, elapsed_seconds: elapsed.round(2), error: error)
-              log.debug("Connection details", server: name, alive: client.alive?, capabilities: caps.inspect)
-
-              result
-                .with_error(name.to_sym, error)
-                .with_context(name.to_sym, { status: :failed })
-                .continue(result.value) # Continue to allow other servers
-            end
-          rescue StandardError => e
-            elapsed = Time.now - start_time
-            error_msg = e.message.downcase.include?('timeout') ?
-              "Connection timed out" : e.message
-
-            log.error("Connection exception", server: name, elapsed_seconds: elapsed.round(2), error_class: e.class.name, error: error_msg)
-            log.debug("Exception backtrace", server: name, backtrace: e.backtrace&.first(3))
-
-            result
-              .with_error(name.to_sym, error_msg)
-              .with_context(name.to_sym, { status: :failed })
-              .continue(result.value)
-          end
-        }
-      end
-
-      def register_single_mcp_client(server)
-        name    = server[:name]    || server['name']
-        command = server[:command] || server['command']
-        args    = server[:args]    || server['args'] || []
-        env     = server[:env]     || server['env'] || {}
-
-        raw_timeout = server[:timeout] || server['timeout'] ||
-                      server[:request_timeout] || server['request_timeout'] ||
-                      MCP_DEFAULT_TIMEOUT
-        request_timeout = raw_timeout.to_i < 1000 ? (raw_timeout.to_i * 1000) : raw_timeout.to_i
-        request_timeout = [request_timeout, 30_000].min
-
-        logger.debug("Configuring client", server: name, command: command, args: args, timeout_ms: request_timeout)
-        logger.debug("Environment variables", server: name, env_keys: env.keys) unless env.empty?
-
-        mcp_config = { command: command, args: Array(args) }
-        mcp_config[:env] = env unless env.empty?
-
-        begin
-          logger.debug("Adding client to RubyLLM::MCP with request_timeout", server: name)
-          RubyLLM::MCP.add_client(
-            name: name,
-            transport_type: :stdio,
-            config: mcp_config,
-            request_timeout: request_timeout,
-            start: false
-          )
-        rescue ArgumentError => e
-          # If request_timeout isn't supported in this version, try without it
-          if e.message.include?('timeout')
-            logger.debug("Retrying without request_timeout (unsupported in this RubyLLM::MCP version)", server: name)
-            RubyLLM::MCP.add_client(
-              name: name,
-              transport_type: :stdio,
-              config: mcp_config,
-              start: false
-            )
-          else
-            logger.error("Failed to add client", server: name, error: e.message)
-            raise
-          end
-        end
-
-        logger.debug("Client registered successfully", server: name)
-        RubyLLM::MCP.clients[name]
-      end
-
-      def determine_mcp_connection_error(client, caps)
-        if !client.alive?
-          "Connection failed"
-        elsif caps.nil?
-          "Connection timed out (no response)"
-        elsif caps.is_a?(Hash) && caps.empty?
-          "Connection timed out (empty capabilities)"
-        else
-          "Connection timed out (no capabilities received)"
-        end
-      end
-
-      def extract_mcp_results(result, tools)
-        logger.debug("Extracting MCP connection results from SimpleFlow pipeline")
-        all_tools = []
-
-        result.context.each do |server_name, info|
-          name = server_name.to_s
-          if info[:status] == :connected
-            tool_count = (info[:tools] || []).size
-            logger.debug("Extracting tools from connected server", server: name, tool_count: tool_count)
-            AIA.config.connected_mcp_servers << name
-            all_tools.concat(info[:tools] || [])
-          end
-        end
-
-        result.errors.each do |server_name, messages|
-          logger.debug("Recording failure", server: server_name, error: messages.first)
-          AIA.config.failed_mcp_servers << {
-            name: server_name.to_s,
-            error: messages.first
-          }
-        end
-
-        tools.concat(all_tools)
-
-        logger.info("MCP results",
-          connected_count: AIA.config.connected_mcp_servers.size,
-          failed_count: AIA.config.failed_mcp_servers.size,
-          total_tools: all_tools.size
-        )
-
-        # Report results
-        report_mcp_connection_results(all_tools.size)
-      end
-
-      def report_mcp_connection_results(tool_count)
-        if AIA.config.connected_mcp_servers.any?
-          logger.info("Successfully connected", servers: AIA.config.connected_mcp_servers)
-          $stderr.puts "MCP: Connected to #{AIA.config.connected_mcp_servers.join(', ')} (#{tool_count} tools)"
-        end
-
-        AIA.config.failed_mcp_servers.each do |failure|
-          logger.warn("Server failed", server: failure[:name], error: failure[:error])
-          $stderr.puts "  MCP: '#{failure[:name]}' failed - #{failure[:error]}"
-        end
-
-        if AIA.config.connected_mcp_servers.empty? && AIA.config.failed_mcp_servers.any?
-          logger.error("No MCP servers connected successfully")
-          $stderr.puts "MCP: No servers connected successfully"
-        end
-
-        $stderr.flush
-      end
-    end
-  end
-end