aia 1.1.0 → 2.0.0.0.pre.alpha

data/lib/aia/chat_processor_service.rb

@@ -1,164 +0,0 @@
-# lib/aia/chat_processor_service.rb
-
-module AIA
-  class ChatProcessorService
-    def initialize(ui_presenter, directive_processor = nil)
-      @ui_presenter = ui_presenter
-      @speaker = AIA.speak? ? AiClient.new(AIA.config.audio.speech_model) : nil
-      @directive_processor = directive_processor
-    end
-
-
-    def speak(text)
-      return unless AIA.speak?
-
-      @speaker ||= AiClient.new(AIA.config.audio.speech_model) if AIA.config.audio.speech_model
-
-      if @speaker
-        system(AIA.config.audio.speak_command, @speaker.speak(text).path)
-      else
-        warn "Warning: Unable to speak. Speech model not configured properly."
-      end
-    end
-
-
-    def process_prompt(prompt)
-      result = nil
-      @ui_presenter.with_spinner("Processing", determine_operation_type) do
-        result = send_to_client(prompt)
-      end
-
-      # Debug output to understand what we're receiving
-      logger.debug("Result received", result_class: result.class.name)
-      logger.debug("Result details", inspect: result.inspect[0..500])
-
-      # Preserve token information if available for metrics
-      if result.is_a?(String)
-        logger.debug("Processing result", type: "String")
-        { content: result, metrics: nil }
-      elsif result.respond_to?(:multi_model?) && result.multi_model?
-        logger.debug("Processing result", type: "multi-model response")
-        # Handle multi-model response with metrics
-        {
-          content: result.content,
-          metrics: nil,  # Individual model metrics handled separately
-          multi_metrics: result.metrics_list
-        }
-      elsif result.respond_to?(:content)
-        logger.debug("Processing result", type: "standard response with content method")
-        # Standard response object with content method
-        {
-          content: result.content,
-          metrics: {
-            input_tokens: result.respond_to?(:input_tokens) ? result.input_tokens : nil,
-            output_tokens: result.respond_to?(:output_tokens) ? result.output_tokens : nil,
-            model_id: result.respond_to?(:model_id) ? result.model_id : nil
-          }
-        }
-      else
-        logger.debug("Processing result", type: "fallback (unexpected type)")
-        # Fallback for unexpected response types
-        { content: result.to_s, metrics: nil }
-      end
-    end
-
-
-    # conversation is an Array of Hashes (single model) or Hash of Arrays (multi-model per-model contexts)
-    # Each entry is an interchange with the LLM.
-    def send_to_client(conversation_or_conversations)
-      maybe_change_model
-
-      # Handle per-model conversations (Hash) or single conversation (Array) - ADR-002 revised
-      if conversation_or_conversations.is_a?(Hash)
-        # Multi-model with per-model contexts: pass Hash directly to adapter
-        logger.debug("Sending per-model conversations to client")
-        result = AIA.client.chat(conversation_or_conversations)
-      else
-        # Single conversation for single model
-        logger.debug("Sending conversation to client", conversation: conversation_or_conversations.inspect[0..500])
-        result = AIA.client.chat(conversation_or_conversations)
-      end
-
-      logger.debug("Client returned", result_class: result.class.name, result: result.inspect[0..500])
-      result
-    end
-
-
-    def maybe_change_model
-      # With multiple models, we don't need to change the model in the same way
-      # The RubyLLMAdapter now handles multiple models internally
-      # This method is kept for backward compatibility but may not be needed
-      models = AIA.config.models
-      return if models.is_a?(Array) && models.size > 1
-
-      return unless AIA.client.respond_to?(:model) && AIA.client.model.respond_to?(:id)
-      client_model = AIA.client.model.id
-
-      # Get the first model name for comparison
-      first_model = models.first
-      model_name = first_model.respond_to?(:name) ? first_model.name : first_model.to_s
-
-      # client_model is the full resolved ID (e.g. "claude-sonnet-4-20250514"),
-      # model_name is the configured alias (e.g. "claude-sonnet-4").
-      # The alias is always a prefix/substring of the resolved ID, so check that way.
-      unless client_model.downcase.include?(model_name.downcase)
-        AIA.client = AIA.client.class.new
-      end
-    end
-
-
-    def output_response(response)
-      speak(response)
-
-      out_file = AIA.config.output.file
-
-      # Output to STDOUT or file based on out_file configuration
-      if out_file.nil? || 'STDOUT' == out_file.upcase
-        print "\nAI:\n  "
-        puts response
-      else
-        mode = AIA.append? ? 'a' : 'w'
-        File.open(out_file, mode) do |file|
-          file.puts "\nAI: "
-          # Handle multi-line responses by adding proper indentation
-          response_lines = response.to_s.split("\n")
-          response_lines.each do |line|
-            file.puts "  #{line}"
-          end
-        end
-      end
-
-      history_file = AIA.config.output.history_file
-      if history_file
-        File.open(history_file, 'a') do |f|
-          f.puts "=== #{Time.now} ==="
-          f.puts "Prompt: #{AIA.config.prompt_id}"
-          f.puts "Response: #{response}"
-          f.puts "==="
-        end
-      end
-    end
-
-
-    def process_next_prompts(response, prompt_handler)
-      if @directive_processor.directive?(response)
-        directive_result = @directive_processor.process(response, @history_manager.history)
-        response = directive_result[:result]
-        @history_manager.history = directive_result[:modified_history] if directive_result[:modified_history]
-      end
-    end
-
-
-    def determine_operation_type
-      # With multiple models, determine operation type from the first model
-      # or provide a generic description
-      models = AIA.config.models
-      if models.is_a?(Array) && models.size > 1
-        "MULTI-MODEL PROCESSING"
-      else
-        mode = AIA.client.model.modalities
-        mode.input.join(',') + " TO " + mode.output.join(',')
-      end
-    end
-  end
-end

data/lib/aia/prompt_pipeline.rb

@@ -1,183 +0,0 @@
-# lib/aia/prompt_pipeline.rb
-# frozen_string_literal: true
-
-require "pm"
-
-module AIA
-  class PromptPipeline
-    include AIA::SkillUtils
-
-    def initialize(prompt_handler, chat_processor, ui_presenter, input_collector)
-      @prompt_handler  = prompt_handler
-      @chat_processor  = chat_processor
-      @ui_presenter    = ui_presenter
-      @input_collector = input_collector
-      @include_context_flag = true
-    end
-
-    # Process all prompts in the pipeline sequentially
-    def process_all
-      prompt_count = 0
-      total_prompts = AIA.config.pipeline.size
-
-      until AIA.config.pipeline.empty?
-        prompt_count += 1
-        prompt_id = AIA.config.pipeline.shift
-
-        puts "\n--- Processing prompt #{prompt_count}/#{total_prompts}: #{prompt_id} ---" if AIA.verbose? && total_prompts > 1
-
-        process_single(prompt_id)
-      end
-    end
-
-    # Process a single prompt with all its requirements
-    def process_single(prompt_id)
-      return if prompt_id.nil? || prompt_id.empty?
-
-      prompt_text = build_prompt_text(prompt_id)
-      return unless prompt_text
-
-      send_and_get_response(prompt_text)
-    end
-
-    def build_prompt_text(prompt_id)
-      role_id = AIA.config.prompts.role
-
-      begin
-        prompt_parsed = @prompt_handler.fetch_prompt(prompt_id)
-      rescue StandardError => e
-        warn "Error processing prompt '#{prompt_id}': #{e.message}"
-        AIA::LoggerManager.aia_logger.error("Error processing prompt '#{prompt_id}': #{e.message}")
-        return nil
-      end
-
-      return nil unless prompt_parsed
-
-      role_parsed = nil
-      unless role_id.nil? || role_id.empty?
-        begin
-          role_parsed = @prompt_handler.fetch_role(role_id)
-        rescue StandardError => e
-          warn "Warning: Could not load role '#{role_id}': #{e.message}"
-          AIA::LoggerManager.aia_logger.warn("Could not load role '#{role_id}': #{e.message}")
-        end
-      end
-
-      # Merge parameters from role and prompt
-      all_params = {}
-      all_params.merge!(role_parsed.metadata.parameters) if role_parsed&.metadata&.parameters
-      all_params.merge!(prompt_parsed.metadata.parameters) if prompt_parsed.metadata&.parameters
-
-      # Collect parameter values from user
-      values = @input_collector.collect(all_params)
-
-      # Render role, skills, and prompt.
-      # Order: role (personality) → skills (task instructions) → prompt (user request)
-      parts = []
-      parts << role_parsed.to_s(values) if role_parsed
-      load_skills(AIA.config.prompts.skills).each { |body| parts << body }
-      parts << prompt_parsed.to_s(values)
-
-      if @include_context_flag
-        # Process stdin content
-        if AIA.config.stdin_content && !AIA.config.stdin_content.strip.empty?
-          parts << PM.parse(AIA.config.stdin_content).to_s
-        end
-      end
-
-      prompt_text = parts.join("\n\n")
-
-      if @include_context_flag
-        prompt_text = add_context_files(prompt_text)
-        @include_context_flag = false
-      end
-
-      prompt_text
-    end
-
-    # Load skill bodies for the given skill IDs in order.
-    # Each skill lives at skills_dir/<name>/SKILL.md; supports prefix matching.
-    # Path-based IDs (starting with /, ~/, ./, ../) are resolved as direct paths.
-    # Returns only the body content (front matter stripped).
-    def load_skills(skill_ids)
-      return [] if skill_ids.nil? || skill_ids.empty?
-
-      skills_dir = AIA.config.skills.dir
-
-      Array(skill_ids).filter_map do |skill_name|
-        skill_name = skill_name.to_s.strip
-        next if skill_name.empty?
-
-        unless path_based_id?(skill_name) || Dir.exist?(skills_dir)
-          warn "Warning: No skill matching '#{skill_name}' found in #{skills_dir}"
-          next
-        end
-
-        skill_dir = find_skill_dir(skill_name, skills_dir)
-        unless skill_dir
-          if path_based_id?(skill_name)
-            warn "Warning: No skill directory found at '#{File.expand_path(skill_name)}'"
-          else
-            warn "Warning: No skill matching '#{skill_name}' found in #{skills_dir}"
-          end
-          next
-        end
-
-        next skill_body(File.read(skill_dir)) if File.file?(skill_dir)
-
-        skill_path = File.join(skill_dir, 'SKILL.md')
-        unless File.exist?(skill_path)
-          warn "Warning: Skill '#{skill_name}' has no SKILL.md in #{skill_dir}"
-          next
-        end
-
-        skill_body(File.read(skill_path))
-      end
-    end
-
-    # Add context files to prompt text
-    def add_context_files(prompt_text)
-      return prompt_text unless 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")
-
-      "#{prompt_text}\n\nContext:\n#{context}"
-    end
-
-    private
-
-    # Send prompt to AI and handle the response
-    def send_and_get_response(prompt_text)
-      response_data = @chat_processor.process_prompt(prompt_text)
-
-      if response_data.is_a?(Hash)
-        content = response_data[:content]
-        metrics = response_data[:metrics]
-        multi_metrics = response_data[:multi_metrics]
-      else
-        content = response_data
-        metrics = nil
-        multi_metrics = nil
-      end
-
-      @chat_processor.output_response(content)
-
-      if AIA.config.flags.tokens
-        if multi_metrics
-          @ui_presenter.display_multi_model_metrics(multi_metrics)
-        elsif metrics
-          @ui_presenter.display_token_metrics(metrics)
-        end
-      end
-
-      # Process any directives in the response
-      directive_processor = DirectiveProcessor.new
-      if directive_processor.directive?(content)
-        directive_result = directive_processor.process(content, nil)
-        puts "\nDirective output: #{directive_result}" if directive_result && !directive_result.strip.empty?
-      end
-    end
-  end
-end

data/lib/aia/ruby_llm_adapter.rb

@@ -1,95 +0,0 @@
-# lib/aia/ruby_llm_adapter.rb
-# frozen_string_literal: true
-
-require 'fileutils'
-require 'json'
-require_relative '../extensions/ruby_llm/provider_fix'
-require_relative 'adapter/gem_activator'
-require_relative 'adapter/provider_configurator'
-require_relative 'adapter/model_registry'
-require_relative 'adapter/tool_loader'
-require_relative 'adapter/mcp_connector'
-require_relative 'adapter/tool_filter'
-require_relative 'adapter/chat_execution'
-require_relative 'adapter/multi_model_chat'
-require_relative 'adapter/modality_handlers'
-require_relative 'adapter/error_handler'
-
-module AIA
-  class RubyLLMAdapter
-    include Adapter::ChatExecution
-    include Adapter::MultiModelChat
-    include Adapter::ModalityHandlers
-    include Adapter::ErrorHandler
-
-    # Re-export for backward compatibility (tests reference AIA::RubyLLMAdapter::MultiModelResponse)
-    MultiModelResponse = Adapter::MultiModelChat::MultiModelResponse
-
-    attr_reader :tools, :model_specs, :chats
-
-    # Delegates to the first chat instance's model object.
-    # Used by single-model callers to inspect the active model.
-    def model
-      @chats.values.first&.model
-    end
-
-    def initialize
-      @model_specs = extract_models_config  # Full specs with role info
-      @models = extract_model_names(@model_specs)  # Just model names for backward compat
-      @chats = {}
-      @contexts = {} # Store isolated contexts for each model
-
-      Adapter::ProviderConfigurator.configure
-      Adapter::ModelRegistry.new.refresh
-      setup_chats_with_tools
-    end
-
-    private
-
-    # Helper to access the AIA logger for application-level logging
-    def logger
-      @logger ||= LoggerManager.aia_logger
-    end
-
-    def extract_models_config
-      # Use config.models which returns array of ModelSpec objects
-      models_config = AIA.config.models
-
-      if models_config.nil? || models_config.empty?
-        # Fallback to default
-        [{model: 'gpt-4o-mini', role: nil, instance: 1, internal_id: 'gpt-4o-mini'}]
-      else
-        # Convert ModelSpec objects to hash format expected by adapter
-        models_config.map do |spec|
-          if spec.respond_to?(:name)
-            # ModelSpec object
-            {model: spec.name, role: spec.role, instance: spec.instance, internal_id: spec.internal_id}
-          elsif spec.is_a?(Hash)
-            # Hash format (legacy or from config.model accessor)
-            model_name = spec[:model] || spec[:name]
-            {model: model_name, role: spec[:role], instance: spec[:instance] || 1, internal_id: spec[:internal_id] || model_name}
-          elsif spec.is_a?(String)
-            # String format (legacy)
-            {model: spec, role: nil, instance: 1, internal_id: spec}
-          else
-            # Unknown format, skip
-            nil
-          end
-        end.compact
-      end
-    end
-
-    def extract_model_names(model_specs)
-      # Extract just the model names from the specs
-      # For models with instance > 1, use internal_id (e.g., "gpt-4o#2")
-      model_specs.map do |spec|
-        spec[:internal_id]
-      end
-    end
-
-    def get_model_spec(internal_id)
-      # Find the spec for a given internal_id
-      @model_specs.find { |spec| spec[:internal_id] == internal_id }
-    end
-  end
-end

data/lib/extensions/openstruct_merge.rb

@@ -1,48 +0,0 @@
-# lib/extensions/openstruct_merge.rb
-#
-
-require 'ostruct'
-
-class OpenStruct
-  def self.merge(*args)
-    result = OpenStruct.new
-
-    args.each do |arg|
-      unless [Hash, OpenStruct].include?(arg.class)
-        raise ArgumentError, "Only OpenStruct or Hash objects are allowed. bad: #{arg.class}"
-      end
-
-      arg.each_pair do |key, value|
-        set_value(result, key, value)
-      end
-    end
-
-    result
-  end
-
-  # Sets value in result OpenStruct, handling nested OpenStruct and Hash objects
-  # Skip nil values to avoid overwriting existing values with nil
-  def self.set_value(result, key, value)
-    # Skip nil values - don't overwrite existing values with nil
-    return if value.nil?
-
-    if value.is_a?(OpenStruct) || value.is_a?(Hash)
-      current_value = result[key]
-      current_value = {} if current_value.nil?
-      merged_value  = merge(current_value, value.to_h)
-      result[key]   = merged_value
-    else
-      result[key] = value
-    end
-  end
-end
-
-__END__
-
-# Usage example
-os1 = OpenStruct.new(a: 1, b: 2, e: OpenStruct.new(x: 9))
-os2 = OpenStruct.new(b: 3, c: 4)
-os3 = {d: 5, e: {y: 10}}
-
-merged_os = OpenStruct.merge(os1, os2, os3)
-puts merged_os.inspect

data/lib/extensions/ruby_llm/.irbrc

@@ -1,56 +0,0 @@
-require 'ruby_llm'
-require_relative 'modalities'
-
-RubyLLM.configure do |config|
-  config.openai_api_key = ENV['OPENAI_API_KEY']
-end
-
-C = RubyLLM::Chat.new
-M = C.model.modalities
-
-__END__
-
-# I = ["text", "image", "pdf", "audio", "file"]
-# O = ["text", "embeddings", "audio", "image", "moderation"]
-
-# I.each do |i|
-#   puts '#'
-#   O.each do |o|
-#     puts <<~HEREDOC
-#       def #{i}_to_#{o}? = input.include?('#{i}') && output.include?('#{o}')
-#     HEREDOC
-#   end
-# end
-
-
-
-#
-def text_to_text? = input.include?('text') && output.include?('text')
-def text_to_embeddings? = input.include?('text') && output.include?('embeddings')
-def text_to_audio? = input.include?('text') && output.include?('audio')
-def text_to_image? = input.include?('text') && output.include?('image')
-def text_to_moderation? = input.include?('text') && output.include?('moderation')
-#
-def image_to_text? = input.include?('image') && output.include?('text')
-def image_to_embeddings? = input.include?('image') && output.include?('embeddings')
-def image_to_audio? = input.include?('image') && output.include?('audio')
-def image_to_image? = input.include?('image') && output.include?('image')
-def image_to_moderation? = input.include?('image') && output.include?('moderation')
-#
-def pdf_to_text? = input.include?('pdf') && output.include?('text')
-def pdf_to_embeddings? = input.include?('pdf') && output.include?('embeddings')
-def pdf_to_audio? = input.include?('pdf') && output.include?('audio')
-def pdf_to_image? = input.include?('pdf') && output.include?('image')
-def pdf_to_moderation? = input.include?('pdf') && output.include?('moderation')
-#
-def audio_to_text? = input.include?('audio') && output.include?('text')
-def audio_to_embeddings? = input.include?('audio') && output.include?('embeddings')
-def audio_to_audio? = input.include?('audio') && output.include?('audio')
-def audio_to_image? = input.include?('audio') && output.include?('image')
-def audio_to_moderation? = input.include?('audio') && output.include?('moderation')
-#
-def file_to_text? = input.include?('file') && output.include?('text')
-def file_to_embeddings? = input.include?('file') && output.include?('embeddings')
-def file_to_audio? = input.include?('file') && output.include?('audio')
-def file_to_image? = input.include?('file') && output.include?('image')
-def file_to_moderation? = input.include?('file') && output.include?('moderation')

data/lib/extensions/ruby_llm/modalities.rb

@@ -1,36 +0,0 @@
-# lib/extensions/ruby_llm/modalities.rb
-
-require 'ruby_llm'
-
-class RubyLLM::Model::Modalities
-  #
-  def text_to_text? = input.include?('text') && output.include?('text')
-  def text_to_embeddings? = input.include?('text') && output.include?('embeddings')
-  def text_to_audio? = input.include?('text') && output.include?('audio')
-  def text_to_image? = input.include?('text') && output.include?('image')
-  def text_to_moderation? = input.include?('text') && output.include?('moderation')
-  #
-  def image_to_text? = input.include?('image') && output.include?('text')
-  def image_to_embeddings? = input.include?('image') && output.include?('embeddings')
-  def image_to_audio? = input.include?('image') && output.include?('audio')
-  def image_to_image? = input.include?('image') && output.include?('image')
-  def image_to_moderation? = input.include?('image') && output.include?('moderation')
-  #
-  def pdf_to_text? = input.include?('pdf') && output.include?('text')
-  def pdf_to_embeddings? = input.include?('pdf') && output.include?('embeddings')
-  def pdf_to_audio? = input.include?('pdf') && output.include?('audio')
-  def pdf_to_image? = input.include?('pdf') && output.include?('image')
-  def pdf_to_moderation? = input.include?('pdf') && output.include?('moderation')
-  #
-  def audio_to_text? = input.include?('audio') && output.include?('text')
-  def audio_to_embeddings? = input.include?('audio') && output.include?('embeddings')
-  def audio_to_audio? = input.include?('audio') && output.include?('audio')
-  def audio_to_image? = input.include?('audio') && output.include?('image')
-  def audio_to_moderation? = input.include?('audio') && output.include?('moderation')
-  #
-  def file_to_text? = input.include?('file') && output.include?('text')
-  def file_to_embeddings? = input.include?('file') && output.include?('embeddings')
-  def file_to_audio? = input.include?('file') && output.include?('audio')
-  def file_to_image? = input.include?('file') && output.include?('image')
-  def file_to_moderation? = input.include?('file') && output.include?('moderation')
-end

data/lib/extensions/ruby_llm/provider_fix.rb

@@ -1,79 +0,0 @@
-# lib/extensions/ruby_llm/provider_fix.rb
-#
-# Monkey patch to fix LM Studio compatibility with RubyLLM
-# LM Studio sometimes returns response.body as a String that fails JSON parsing
-# This causes "String does not have #dig method" errors in parse_error
-
-# Load RubyLLM first to ensure Provider class exists
-require 'ruby_llm'
-
-module RubyLLM
-  module ProviderErrorFix
-    # Override the parse_error method to handle String responses from LM Studio
-    # Parses error response from provider API.
-    #
-    # Supports two error formats:
-    # 1. OpenAI standard: {"error": {"message": "...", "type": "...", "code": "..."}}
-    # 2. Simple format: {"error": "error message"}
-    #
-    # @param response [Faraday::Response] The HTTP response
-    # @return [String, nil] The error message or nil if parsing fails
-    #
-    # @example OpenAI format
-    #   response = double(body: '{"error": {"message": "Rate limit exceeded"}}')
-    #   parse_error(response) #=> "Rate limit exceeded"
-    #
-    # @example Simple format (LM Studio, some local providers)
-    #   response = double(body: '{"error": "Token limit exceeded"}')
-    #   parse_error(response) #=> "Token limit exceeded"
-    def parse_error(response)
-      return if response.body.empty?
-
-      body = try_parse_json(response.body)
-      case body
-      when Hash
-        # Handle both formats:
-        # - {"error": "message"}          (LM Studio, some providers)
-        # - {"error": {"message": "..."}} (OpenAI standard)
-        error_value = body['error']
-        return nil unless error_value
-
-        case error_value
-        when Hash
-          error_value['message']
-        when String
-          error_value
-        else
-          error_value.to_s if error_value
-        end
-      when Array
-        body.filter_map do |part|
-          next unless part.is_a?(Hash)
-
-          error_value = part['error']
-          next unless error_value
-
-          case error_value
-          when Hash then error_value['message']
-          when String then error_value
-          else error_value.to_s if error_value
-          end
-        end.join('. ')
-      else
-        body.to_s
-      end
-    rescue StandardError => e
-      RubyLLM.logger.debug "Error parsing response: #{e.message}"
-      nil
-    end
-  end
-end
-
-# Apply the prepend to all Provider subclasses
-# LM Studio uses the OpenAI provider, so we need to prepend to all provider classes
-RubyLLM::Provider.prepend(RubyLLM::ProviderErrorFix)
-
-# Also prepend to all registered provider classes
-RubyLLM::Provider.providers.each do |slug, provider_class|
-  provider_class.prepend(RubyLLM::ProviderErrorFix)
-end

data/lib/refinements/string.rb

@@ -1,16 +0,0 @@
-# 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