aia 0.9.24 → 0.10.2

data/lib/aia/config.rb

@@ -1,30 +1,349 @@
+# frozen_string_literal: true
+
 # lib/aia/config.rb
 #
-# This file contains the configuration settings for the AIA application.
-# The Config class is responsible for managing configuration settings
-# for the AIA application. It provides methods to parse command-line
-# arguments, environment variables, and configuration files.
+# AIA Configuration using Anyway Config
+#
+# Schema is defined in lib/aia/config/defaults.yml (single source of truth)
+# Configuration uses nested sections for better organization:
+#   - AIA.config.llm.temperature
+#   - AIA.config.prompts.dir
+#   - AIA.config.models.first.name
+#
+# Configuration sources (lowest to highest priority):
+# 1. Bundled defaults: lib/aia/config/defaults.yml (ships with gem)
+# 2. User config: ~/.aia/config.yml
+# 3. Environment variables (AIA_*)
+# 4. CLI arguments (applied via overrides)
+# 5. Embedded directives (//config)
+
+require 'anyway_config'
+require 'yaml'
+require 'date'
 
-require_relative 'config/base'
+require_relative 'config/config_section'
+require_relative 'config/model_spec'
+require_relative 'config/defaults_loader'
+require_relative 'config/mcp_parser'
 
 module AIA
-  class Config
-    # Delegate all functionality to the modular config system
-    def self.setup
-      ConfigModules::Base.setup
+  class Config < Anyway::Config
+    config_name :aia
+    env_prefix :aia
+
+    # ==========================================================================
+    # Schema Definition (loaded from defaults.yml - single source of truth)
+    # ==========================================================================
+
+    DEFAULTS_PATH = File.expand_path('config/defaults.yml', __dir__).freeze
+    SCHEMA = Loaders::DefaultsLoader.schema
+
+    # Nested section attributes (defined as hashes, converted to ConfigSection)
+    attr_config :service, :llm, :prompts, :output, :audio, :image, :embedding,
+                :tools, :flags, :registry, :paths, :logger
+
+    # Array/collection attributes
+    attr_config :models, :pipeline, :require_libs, :mcp_servers, :context_files
+
+    # Runtime attributes (not loaded from config files)
+    attr_accessor :prompt_id, :stdin_content, :remaining_args, :dump_file,
+                  :completion, :executable_prompt,
+                  :executable_prompt_file, :tool_names, :loaded_tools, :next_prompt,
+                  :log_level_override, :log_file_override,
+                  :connected_mcp_servers, # Array of successfully connected MCP server names
+                  :failed_mcp_servers     # Array of {name:, error:} hashes for failed MCP servers
+
+    # Alias for next prompt (for backward compatibility with directives)
+    def next
+      @next_prompt
+    end
+
+    def next=(value)
+      @next_prompt = value
+      # Also prepend to pipeline
+      pipeline.unshift(value) if value && !value.empty?
+    end
+
+    # ==========================================================================
+    # Type Coercion
+    # ==========================================================================
+
+    # Create a coercion that merges incoming value with SCHEMA defaults for a section
+    def self.config_section_with_defaults(section_key)
+      defaults = SCHEMA[section_key] || {}
+      ->(v) {
+        return v if v.is_a?(ConfigSection)
+        incoming = v || {}
+        merged = deep_merge_hashes(defaults.dup, incoming)
+        ConfigSection.new(merged)
+      }
+    end
+
+    # Deep merge helper for coercion
+    def self.deep_merge_hashes(base, overlay)
+      base.merge(overlay || {}) do |_key, old_val, new_val|
+        if old_val.is_a?(Hash) && new_val.is_a?(Hash)
+          deep_merge_hashes(old_val, new_val)
+        else
+          new_val.nil? ? old_val : new_val
+        end
+      end
+    end
+
+    # Convert array of hashes to array of ModelSpec objects
+    TO_MODEL_SPECS = ->(v) {
+      return [] if v.nil?
+      return v if v.is_a?(Array) && v.first.is_a?(ModelSpec)
+
+      model_counts = Hash.new(0)
+
+      Array(v).map do |spec|
+        # Handle string format from CLI
+        if spec.is_a?(String)
+          if spec.include?('=')
+            name, role = spec.split('=', 2)
+            spec = { name: name.strip, role: role.strip }
+          else
+            spec = { name: spec.strip }
+          end
+        end
+
+        spec = spec.transform_keys(&:to_sym) if spec.respond_to?(:transform_keys)
+        name = spec[:name]
+
+        model_counts[name] += 1
+        instance = model_counts[name]
+
+        ModelSpec.new(
+          name: name,
+          role: spec[:role],
+          instance: instance,
+          internal_id: instance > 1 ? "#{name}##{instance}" : name
+        )
+      end
+    }
+
+    coerce_types(
+      # Nested sections -> ConfigSection objects (with SCHEMA defaults merged)
+      service: config_section_with_defaults(:service),
+      llm: config_section_with_defaults(:llm),
+      prompts: config_section_with_defaults(:prompts),
+      output: config_section_with_defaults(:output),
+      audio: config_section_with_defaults(:audio),
+      image: config_section_with_defaults(:image),
+      embedding: config_section_with_defaults(:embedding),
+      tools: config_section_with_defaults(:tools),
+      flags: config_section_with_defaults(:flags),
+      registry: config_section_with_defaults(:registry),
+      paths: config_section_with_defaults(:paths),
+
+      # Arrays
+      models: TO_MODEL_SPECS,
+      pipeline: { type: :string, array: true },
+      require_libs: { type: :string, array: true },
+      context_files: { type: :string, array: true }
+    )
+
+    # ==========================================================================
+    # Callbacks
+    # ==========================================================================
+
+    on_load :expand_paths, :ensure_arrays
+
+    # ==========================================================================
+    # Class Methods
+    # ==========================================================================
+
+    class << self
+      # Setup configuration with CLI overrides
+      #
+      # @param cli_overrides [Hash] overrides from CLI parsing
+      # @return [Config] configured instance
+      def setup(cli_overrides = {})
+        new(overrides: cli_overrides)
+      end
+    end
+
+    # ==========================================================================
+    # Instance Methods
+    # ==========================================================================
+
+    # Mapping of flat CLI keys to their nested config locations
+    CLI_TO_NESTED_MAP = {
+      # flags section
+      chat: [:flags, :chat],
+      cost: [:flags, :cost],
+      fuzzy: [:flags, :fuzzy],
+      tokens: [:flags, :tokens],
+      no_mcp: [:flags, :no_mcp],
+      terse: [:flags, :terse],
+      debug: [:flags, :debug],
+      verbose: [:flags, :verbose],
+      consensus: [:flags, :consensus],
+      # llm section
+      adapter: [:llm, :adapter],
+      temperature: [:llm, :temperature],
+      max_tokens: [:llm, :max_tokens],
+      top_p: [:llm, :top_p],
+      frequency_penalty: [:llm, :frequency_penalty],
+      presence_penalty: [:llm, :presence_penalty],
+      # prompts section
+      prompts_dir: [:prompts, :dir],
+      roles_prefix: [:prompts, :roles_prefix],
+      role: [:prompts, :role],
+      parameter_regex: [:prompts, :parameter_regex],
+      system_prompt: [:prompts, :system_prompt],
+      # output section
+      output: [:output, :file],
+      history_file: [:output, :history_file],
+      append: [:output, :append],
+      markdown: [:output, :markdown],
+      # audio section
+      speak: [:audio, :speak],
+      voice: [:audio, :voice],
+      speech_model: [:audio, :speech_model],
+      transcription_model: [:audio, :transcription_model],
+      # image section
+      image_size: [:image, :size],
+      image_quality: [:image, :quality],
+      image_style: [:image, :style],
+      # tools section
+      tool_paths: [:tools, :paths],
+      allowed_tools: [:tools, :allowed],
+      rejected_tools: [:tools, :rejected],
+      # registry section
+      refresh: [:registry, :refresh],
+      # paths section
+      extra_config_file: [:paths, :extra_config_file]
+    }.freeze
+
+    def initialize(overrides: {})
+      super()
+      apply_overrides(overrides) if overrides && !overrides.empty?
+      process_mcp_files(overrides[:mcp_files]) if overrides[:mcp_files]
     end
 
-    # Maintain backward compatibility by delegating to Base module
-    def self.method_missing(method_name, *args, &block)
-      if ConfigModules::Base.respond_to?(method_name)
-        ConfigModules::Base.send(method_name, *args, &block)
-      else
-        super
+    # Apply CLI or runtime overrides to configuration
+    #
+    # @param overrides [Hash] key-value pairs to override
+    def apply_overrides(overrides)
+      overrides.each do |key, value|
+        next if value.nil?
+
+        key_sym = key.to_sym
+
+        # Check if this is a flat CLI key that maps to a nested location
+        if CLI_TO_NESTED_MAP.key?(key_sym)
+          section, nested_key = CLI_TO_NESTED_MAP[key_sym]
+          section_obj = send(section)
+          section_obj.send("#{nested_key}=", value) if section_obj.respond_to?("#{nested_key}=")
+        elsif respond_to?("#{key}=")
+          send("#{key}=", value)
+        elsif key.to_s.include?('__')
+          # Handle nested keys like 'llm__temperature'
+          parts = key.to_s.split('__')
+          apply_nested_override(parts, value)
+        end
       end
     end
 
-    def self.respond_to_missing?(method_name, include_private = false)
-      ConfigModules::Base.respond_to?(method_name, include_private) || super
+    # Convert config to hash (for dump, etc.)
+    def to_h
+      {
+        service: service.to_h,
+        llm: llm.to_h,
+        models: models.map(&:to_h),
+        prompts: prompts.to_h,
+        output: output.to_h,
+        audio: audio.to_h,
+        image: image.to_h,
+        embedding: embedding.to_h,
+        tools: tools.to_h,
+        flags: flags.to_h,
+        registry: registry.to_h,
+        paths: paths.to_h,
+        pipeline: pipeline,
+        require_libs: require_libs,
+        mcp_servers: mcp_servers,
+        context_files: context_files
+      }
+    end
+
+    private
+
+    def expand_paths
+      # Expand ~ in paths
+      if paths.aia_dir
+        paths.aia_dir = File.expand_path(paths.aia_dir)
+      end
+
+      if paths.config_file
+        paths.config_file = File.expand_path(paths.config_file)
+      end
+
+      if prompts.dir
+        prompts.dir = File.expand_path(prompts.dir)
+      end
+
+      if prompts.roles_dir
+        prompts.roles_dir = File.expand_path(prompts.roles_dir)
+      end
+
+      if output.history_file
+        output.history_file = File.expand_path(output.history_file)
+      end
+    end
+
+    def ensure_arrays
+      # Ensure array fields are actually arrays
+      self.pipeline = [] if pipeline.nil?
+      self.require_libs = [] if require_libs.nil?
+      self.context_files = [] if context_files.nil?
+      self.mcp_servers = [] if mcp_servers.nil?
+
+      # Ensure tools.paths is an array
+      tools.paths = [] if tools.paths.nil?
+    end
+
+    # Process MCP JSON files and merge servers into mcp_servers
+    #
+    # @param mcp_files [Array<String>] paths to MCP JSON configuration files
+    def process_mcp_files(mcp_files)
+      return if mcp_files.nil? || mcp_files.empty?
+
+      servers_from_files = McpParser.parse_files(mcp_files)
+      return if servers_from_files.empty?
+
+      # Merge with existing mcp_servers (CLI files take precedence)
+      self.mcp_servers = (mcp_servers || []) + servers_from_files
+    end
+
+    def apply_nested_override(parts, value)
+      section = parts[0].to_sym
+      key = parts[1].to_sym
+
+      case section
+      when :llm
+        llm.send("#{key}=", value) if llm.respond_to?("#{key}=")
+      when :prompts
+        prompts.send("#{key}=", value) if prompts.respond_to?("#{key}=")
+      when :output
+        output.send("#{key}=", value) if output.respond_to?("#{key}=")
+      when :audio
+        audio.send("#{key}=", value) if audio.respond_to?("#{key}=")
+      when :image
+        image.send("#{key}=", value) if image.respond_to?("#{key}=")
+      when :embedding
+        embedding.send("#{key}=", value) if embedding.respond_to?("#{key}=")
+      when :tools
+        tools.send("#{key}=", value) if tools.respond_to?("#{key}=")
+      when :flags
+        flags.send("#{key}=", value) if flags.respond_to?("#{key}=")
+      when :registry
+        registry.send("#{key}=", value) if registry.respond_to?("#{key}=")
+      when :paths
+        paths.send("#{key}=", value) if paths.respond_to?("#{key}=")
+      end
     end
   end
 end

data/lib/aia/directive_processor.rb

@@ -1,6 +1,6 @@
 # lib/aia/directive_processor.rb
 
-require 'active_support/all'
+# require 'active_support/all'
 require 'faraday'
 require 'word_wrapper'
 require_relative 'directives/registry'
@@ -9,7 +9,7 @@ module AIA
   class DirectiveProcessor
     using Refinements
 
-    EXCLUDED_METHODS = %w[ run initialize private? ]
+    EXCLUDED_METHODS = %w[run initialize private?]
 
     def initialize
       @prefix_size = PromptManager::Prompt::DIRECTIVE_SIGNAL.size
@@ -17,18 +17,24 @@ module AIA
       Directives::WebAndFile.included_files = @included_files
     end
 
+
     def directive?(string)
       Directives::Registry.directive?(string)
     end
 
+
     def process(string, context_manager)
       return string unless directive?(string)
 
       content = if string.is_a?(RubyLLM::Message)
-                 string.content rescue string.to_s
-               else
-                 string.to_s
-               end
+                  begin
+                    string.content
+                  rescue StandardError
+                    string.to_s
+                  end
+                else
+                  string.to_s
+                end
 
       key = content.strip
       sans_prefix = key[@prefix_size..]
@@ -38,6 +44,7 @@ module AIA
       Directives::Registry.process(method_name, args, context_manager)
     end
 
+
     def run(directives)
       return {} if directives.nil? || directives.empty?
 
@@ -76,6 +83,7 @@ module AIA
       end
     end
 
+
     def respond_to_missing?(method_name, include_private = false)
       Directives::Registry.respond_to?(method_name, include_private) || super
     end

data/lib/aia/directives/configuration.rb

@@ -7,12 +7,17 @@ module AIA
           args = Array(args)
 
           if args.empty?
-            ap AIA.config
+            ap AIA.config.to_h
             ""
           elsif args.length == 1
             config_item = args.first
-            local_cfg = Hash.new
-            local_cfg[config_item] = AIA.config[config_item]
+            local_cfg = {}
+            # Use method-based access for Anyway::Config
+            if AIA.config.respond_to?(config_item)
+              local_cfg[config_item] = AIA.config.send(config_item)
+            else
+              local_cfg[config_item] = nil
+            end
             ap local_cfg
             ""
           else
@@ -24,7 +29,13 @@ module AIA
               new_value = %w[true t yes y on 1 yea yeah yep yup].include?(new_value.downcase)
             end
 
-            AIA.config[config_item] = new_value
+            # Use method-based setter for Anyway::Config
+            setter = "#{config_item}="
+            if AIA.config.respond_to?(setter)
+              AIA.config.send(setter, new_value)
+            else
+              puts "Warning: Unknown config option '#{config_item}'"
+            end
             ""
           end
         end
@@ -33,29 +44,32 @@ module AIA
           if args.empty?
             # Display details for all configured models
             puts
-            models = Array(AIA.config.model)
+            models = AIA.config.models
 
             if models.size == 1
               puts "Current Model:"
               puts "=============="
-              puts AIA.config.client.model.to_h.pretty_inspect
+              puts AIA.client.model.to_h.pretty_inspect
             else
               puts "Multi-Model Configuration:"
               puts "=========================="
               puts "Model count: #{models.size}"
-              puts "Primary model: #{models.first} (used for consensus when --consensus flag is enabled)"
-              puts "Consensus mode: #{AIA.config.consensus.nil? ? 'auto-detect (disabled by default)' : AIA.config.consensus}"
+              first_model = models.first.respond_to?(:name) ? models.first.name : models.first.to_s
+              puts "Primary model: #{first_model} (used for consensus when --consensus flag is enabled)"
+              consensus = AIA.config.flags.consensus
+              puts "Consensus mode: #{consensus.nil? ? 'auto-detect (disabled by default)' : consensus}"
               puts
               puts "Model Details:"
               puts "-" * 50
 
-              models.each_with_index do |model_name, index|
+              models.each_with_index do |model_spec, index|
+                model_name = model_spec.respond_to?(:name) ? model_spec.name : model_spec.to_s
                 puts "#{index + 1}. #{model_name}#{index == 0 ? ' (primary)' : ''}"
 
                 # Try to get model details if available
                 begin
                   # Access the model details from RubyLLM's model registry
-                  model_info = RubyLLM::Models.find(name: model_name)
+                  model_info = RubyLLM::Models.find(model_name)
                   if model_info
                     puts "   Provider: #{model_info.provider || 'Unknown'}"
                     puts "   Context window: #{model_info.context_window || 'Unknown'}"

data/lib/aia/directives/models.rb

@@ -31,12 +31,11 @@ module AIA
 
       def self.available_models(args = nil, context_manager = nil)
           # Check if we're using a local provider
-          current_models = AIA.config.model
-          current_models = [current_models] if current_models.is_a?(String)
+          current_models = AIA.config.models
 
-          # Extract model names (handles both String and Hash formats)
+          # Extract model names (handles ModelSpec objects)
           model_names = current_models.map do |m|
-            m.is_a?(Hash) ? m[:model] : m
+            m.respond_to?(:name) ? m.name : m.to_s
           end
 
           using_local_provider = model_names.any? { |m| m.start_with?('ollama/', 'lms/') }

data/lib/aia/directives/utility.rb

@@ -14,10 +14,11 @@ module AIA
           width = TTY::Screen.width - indent - 2
           filter = args.first&.downcase
 
-          if AIA.config.tools.empty?
+          loaded_tools = AIA.config.loaded_tools || []
+          if loaded_tools.empty?
             puts "No tools are available"
           else
-            tools_to_display = AIA.config.tools
+            tools_to_display = loaded_tools
 
             if filter
               tools_to_display = tools_to_display.select do |tool|

data/lib/aia/directives/web_and_file.rb

@@ -1,7 +1,7 @@
 # lib/aia/directives/web_and_file.rb
 
 require 'faraday'
-require 'active_support/all'
+# require 'active_support/all'
 require 'clipboard'
 
 module AIA
@@ -9,73 +9,76 @@ module AIA
     module WebAndFile
       PUREMD_API_KEY = ENV.fetch('PUREMD_API_KEY', nil)
 
-      def self.webpage(args, context_manager = nil)
-          if PUREMD_API_KEY.nil?
-            "ERROR: PUREMD_API_KEY is required in order to include a webpage"
+      def self.webpage(args, _context_manager = nil)
+        if PUREMD_API_KEY.nil?
+          'ERROR: PUREMD_API_KEY is required in order to include a webpage'
+        else
+          url = `echo #{args.shift}`.strip
+          puremd_url = "https://pure.md/#{url}"
+
+          response = Faraday.get(puremd_url) do |req|
+            req.headers['x-puremd-api-token'] = PUREMD_API_KEY
+          end
+
+          if 200 == response.status
+            response.body
           else
-            url = `echo #{args.shift}`.strip
-            puremd_url = "https://pure.md/#{url}"
-
-            response = Faraday.get(puremd_url) do |req|
-              req.headers['x-puremd-api-token'] = PUREMD_API_KEY
-            end
-
-            if 200 == response.status
-              response.body
-            else
-              "Error: Status was #{response.status}\n#{ap response}"
-            end
+            "Error: Status was #{response.status}\n#{ap response}"
           end
         end
+      end
 
-      def self.include(args, context_manager = nil)
-          # echo takes care of envars and tilde expansion
-          file_path = `echo #{args.shift}`.strip
 
-          if file_path.start_with?(/http?:\/\//)
-            webpage(args)
-          else
-            include_file(file_path)
-          end
+      def self.include(args, _context_manager = nil)
+        # echo takes care of envars and tilde expansion
+        file_path = `echo #{args.shift}`.strip
+
+        if file_path.start_with?(%r{http?://})
+          webpage(args)
+        else
+          include_file(file_path)
         end
+      end
 
-        def self.include_file(file_path)
-          @included_files ||= []
-          if @included_files.include?(file_path)
-            ""
-          else
-            if File.exist?(file_path) && File.readable?(file_path)
-              @included_files << file_path
-              File.read(file_path)
-            else
-              "Error: File '#{file_path}' is not accessible"
-            end
-          end
+
+      def self.include_file(file_path)
+        @included_files ||= []
+        if @included_files.include?(file_path)
+          ''
+        elsif File.exist?(file_path) && File.readable?(file_path)
+          @included_files << file_path
+          File.read(file_path)
+        else
+          "Error: File '#{file_path}' is not accessible"
         end
+      end
+
 
       def self.included_files
         @included_files ||= []
       end
 
+
       def self.included_files=(files)
         @included_files = files
       end
 
-      def self.paste(args = [], context_manager = nil)
-        begin
-          content = Clipboard.paste
-          content.to_s
-        rescue => e
-          "Error: Unable to paste from clipboard - #{e.message}"
-        end
+
+      def self.paste(_args = [], _context_manager = nil)
+
+        content = Clipboard.paste
+        content.to_s
+      rescue StandardError => e
+        "Error: Unable to paste from clipboard - #{e.message}"
+
       end
 
       # Set up aliases - these work on the module's singleton class
       class << self
-        alias_method :website, :webpage
-        alias_method :web, :webpage
-        alias_method :import, :include
-        alias_method :clipboard, :paste
+        alias website webpage
+        alias web webpage
+        alias import include
+        alias clipboard paste
       end
     end
   end