aia 1.1.0 → 2.0.0.0.pre.alpha

data/lib/aia/config/validator.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'word_wrapper'
-require_relative '../adapter/gem_activator'
 require_relative '../skill_utils'
 
 # lib/aia/config/validator.rb
@@ -10,6 +9,7 @@ require_relative '../skill_utils'
 # Handles prompt ID extraction, context file validation, role processing, etc.
 
 module AIA
+  # rubocop:disable Metrics/ModuleLength
   module ConfigValidator
     class << self
       # Tailor and validate the configuration
@@ -24,35 +24,42 @@ module AIA
         stdin_content = process_stdin_content
         config.stdin_content = stdin_content if stdin_content && !stdin_content.strip.empty?
 
+        # Tool files may define AIA::Directive subclasses used by PromptManager.
+        require_tool_files(config)
+
         # Process arguments and validate
         process_prompt_id_from_args(config, remaining_args)
         validate_and_set_context_files(config, remaining_args)
         handle_executable_prompt(config)
         handle_stdin_as_prompt(config)
-        handle_dump_config(config)
-        handle_mcp_list(config)
-        handle_list_tools(config)
-        handle_list_skills(config)
-        handle_completion_script(config)
+        return :early_exit if handle_early_exits(config) == :early_exit
         validate_required_prompt_id(config)
         process_role_configuration(config)
+        validate_plugins_dir(config)
         handle_fuzzy_search_prompt_id(config)
         normalize_boolean_flags(config)
         validate_final_prompt_requirements(config)
-        configure_prompt_manager(config)
         prepare_pipeline(config)
         validate_pipeline_prompts(config)
 
         config
       end
 
+      def handle_early_exits(config)
+        return :early_exit if handle_dump_config(config)       == :early_exit
+        return :early_exit if handle_mcp_list(config)          == :early_exit
+        return :early_exit if handle_list_tools(config)        == :early_exit
+        return :early_exit if handle_list_skills(config)       == :early_exit
+        :early_exit if handle_completion_script(config) == :early_exit
+      end
+
       def process_stdin_content
         stdin_content = String.new
 
-        if !STDIN.tty? && !STDIN.closed?
+        if !$stdin.tty? && !$stdin.closed?
           begin
-            stdin_content << "\n" + STDIN.read
-            STDIN.reopen('/dev/tty')
+            stdin_content << ("\n" + $stdin.read)
+            $stdin.reopen('/dev/tty')
           rescue => _
             # If we can't reopen, continue without error
           end
@@ -67,9 +74,8 @@ module AIA
         maybe_id = remaining_args.first
         maybe_id_plus = File.join(config.prompts.dir, maybe_id + config.prompts.extname)
 
-        if AIA.bad_file?(maybe_id) && AIA.good_file?(maybe_id_plus)
-          config.prompt_id = remaining_args.shift
-        end
+        return unless AIA.bad_file?(maybe_id) && AIA.good_file?(maybe_id_plus)
+        config.prompt_id = remaining_args.shift
       end
 
       def validate_and_set_context_files(config, remaining_args)
@@ -77,8 +83,16 @@ module AIA
 
         bad_files = remaining_args.reject { |filename| AIA.good_file?(filename) }
         if bad_files.any?
-          warn "Error: The following files do not exist: #{bad_files.join(', ')}"
-          exit 1
+          # Detect likely flag typos: "_B" instead of "-B", "_CD" instead of "-CD", etc.
+          flag_typos = bad_files.grep(/\A_[A-Za-z]/)
+          if flag_typos.any?
+            suggestions = flag_typos.map { |f| "-#{f[1..]}" }.join(', ')
+            raise AIA::ConfigurationError,
+                  "Unknown argument(s): #{flag_typos.join(', ')}\n" \
+                  "Did you mean: #{suggestions}?\n" \
+                  "Flags require a dash prefix (e.g., -B not _B)."
+          end
+          raise AIA::ConfigurationError, "The following files do not exist: #{bad_files.join(', ')}"
         end
 
         config.context_files ||= []
@@ -86,7 +100,6 @@ module AIA
       end
 
       def handle_executable_prompt(config)
-        # Auto-detect: no prompt_id, first context_file starts with shebang
         return unless config.prompt_id.nil?
         return unless config.context_files && !config.context_files.empty?
 
@@ -96,7 +109,6 @@ module AIA
         first_line = File.open(candidate, &:readline).strip rescue nil
         return unless first_line&.start_with?('#!')
 
-        # This is an executable prompt — the file content IS the prompt
         config.context_files.shift
         config.executable_prompt_content = File.read(candidate).lines[1..].join
         config.prompt_id = '__EXECUTABLE_PROMPT__'
@@ -108,21 +120,20 @@ module AIA
 
         content = config.stdin_content
 
-        # Strip shebang line if present (e.g., piped from an executable prompt)
         if content.lines.first&.strip&.start_with?('#!')
           content = content.lines[1..].join
         end
 
         config.executable_prompt_content = content
-        config.stdin_content = nil  # prevent double-processing in build_prompt_text
+        config.stdin_content = nil
         config.prompt_id = '__EXECUTABLE_PROMPT__'
       end
 
       def validate_required_prompt_id(config)
-        return unless config.prompt_id.nil? && !(config.flags.chat == true) && !(config.flags.fuzzy == true)
+        return unless config.prompt_id.nil? && config.flags.chat != true && config.flags.fuzzy != true
 
-        warn "Error: A prompt ID is required unless using --chat, --fuzzy, or providing context files. Use -h or --help for help."
-        exit 1
+        raise AIA::ConfigurationError,
+              "A prompt ID is required unless using --chat, --fuzzy, or providing context files. Use -h or --help for help."
       end
 
       def process_role_configuration(config)
@@ -130,7 +141,6 @@ module AIA
         return if role.nil? || role.empty?
 
         roles_prefix = config.prompts.roles_prefix
-
         unless AIA::SkillUtils.path_based_id?(role) || roles_prefix.nil? || roles_prefix.empty? || role.start_with?(roles_prefix)
           config.prompts.role = "#{roles_prefix}/#{role}"
           role = config.prompts.role
@@ -138,18 +148,21 @@ module AIA
 
         config.prompts.roles_dir ||= File.join(config.prompts.dir, roles_prefix.to_s)
 
-        # In chat-only mode (no prompt_id), leave the role configured so ChatLoop
-        # can inject it as initial context. Promoting it to prompt_id would cause
-        # PM to receive the role path as a literal string rather than file content.
         return if config.flags&.chat == true
 
-        if config.prompt_id.nil? || config.prompt_id.empty?
-          unless role.nil? || role.empty?
-            config.prompt_id = role
-            config.pipeline.prepend(config.prompt_id)
-            config.prompts.role = ''
-          end
-        end
+        return unless config.prompt_id.nil? || config.prompt_id.empty?
+        return if role.nil? || role.empty?
+        config.prompt_id = role
+        config.pipeline.prepend(config.prompt_id)
+        config.prompts.role = ''
+      end
+
+      def validate_plugins_dir(config)
+        plugins_dir = config.paths&.plugins_dir
+        return if plugins_dir.nil? || plugins_dir.to_s.strip.empty?
+        return if Dir.exist?(plugins_dir)
+
+        $stderr.puts "Warning: configured plugins directory does not exist: #{plugins_dir}"
       end
 
       def handle_fuzzy_search_prompt_id(config)
@@ -184,12 +197,12 @@ module AIA
         return unless config.dump_file
 
         dump_config(config, config.dump_file)
-        exit 0
+        :early_exit
       end
 
       def handle_mcp_list(config)
         return unless config.mcp_list
-        return if config.list_tools  # defer to handle_list_tools for combined output
+        return if config.list_tools
 
         servers = filter_mcp_servers(config)
 
@@ -199,17 +212,18 @@ module AIA
           label = mcp_filter_active?(config) ? "Active" : "Configured"
           puts "#{label} MCP servers:\n\n"
           servers.each do |server|
-            name    = server[:name]    || server['name']    || '(unnamed)'
-            command = server[:command] || server['command']  || '(no command)'
-            args    = server[:args]    || server['args']     || []
-            args_str = args.empty? ? '' : " #{args.join(' ')}"
+            name      = AIA::Utility.server_name(server) || '(unnamed)'
+            transport = server[:transport] || server['transport'] || {}
+            command   = transport[:command] || transport['command'] || server[:command] || server['command'] || '(no command)'
+            args      = transport[:args] || transport['args'] || server[:args] || server['args'] || []
+            args_str  = args.empty? ? '' : " #{args.join(' ')}"
             puts "  #{name}"
             puts "    command: #{command}#{args_str}"
             puts
           end
         end
 
-        exit 0
+        :early_exit
       end
 
       def handle_list_tools(config)
@@ -224,7 +238,7 @@ module AIA
 
         if local_tools.empty? && mcp_tool_groups.empty?
           $stderr.puts "No tools available."
-          exit 0
+          return :early_exit
         end
 
         if $stdout.tty?
@@ -233,41 +247,7 @@ module AIA
           list_tools_markdown(local_tools, mcp_tool_groups)
         end
 
-        exit 0
-      end
-
-      def handle_list_skills(config)
-        return unless config.list_skills
-
-        skills_dir = AIA.config.skills.dir
-
-        unless Dir.exist?(skills_dir)
-          $stderr.puts "No skills directory found at #{skills_dir}"
-          exit 0
-        end
-
-        skill_dirs = Dir.glob("*/SKILL.md", base: skills_dir).map { |f| File.dirname(f) }.sort
-
-        if skill_dirs.empty?
-          $stderr.puts "No skills found in #{skills_dir}"
-          exit 0
-        end
-
-        skill_dirs.each do |skill_name|
-          skill_md = File.join(skills_dir, skill_name, 'SKILL.md')
-          fm = AIA::SkillUtils.parse_front_matter(skill_md)
-
-          puts "## #{skill_name}"
-          puts
-          puts "| Key | Value |"
-          puts "|-----|-------|"
-          fm.each do |key, value|
-            puts "| #{key} | #{value} |"
-          end
-          puts
-        end
-
-        exit 0
+        :early_exit
       end
 
       def list_tools_terminal(local_tools, mcp_tool_groups)
@@ -326,25 +306,20 @@ module AIA
 
         puts "### `#{name}`"
         puts
-        unless desc.empty?
-          puts nest_markdown_headings(desc, 3)
-          puts
-        end
+        return if desc.empty?
+        puts nest_markdown_headings(desc, 3)
+        puts
       end
 
-      # Adjusts any markdown headings in text so they nest under the
-      # given parent heading level. e.g. with parent_level=3 (###),
-      # a "# Foo" becomes "#### Foo" and "## Bar" becomes "##### Bar".
-      # Handles headings with optional leading whitespace.
       def nest_markdown_headings(text, parent_level)
-        text.gsub(/^[ \t]*(\#{1,6})\s/) do |match|
-          existing = $1
-          "#" * (existing.length + parent_level) + " "
+        text.gsub(/^[ \t]*(\#{1,6})\s/) do |_match|
+          existing = ::Regexp.last_match(1)
+          ("#" * (existing.length + parent_level)) + " "
         end
       end
 
       def filter_mcp_servers(config)
-        servers  = config.mcp_servers || []
+        servers = config.mcp_servers || []
         use_list  = Array(config.mcp_use)
         skip_list = Array(config.mcp_skip)
 
@@ -361,19 +336,38 @@ module AIA
         !Array(config.mcp_use).empty? || !Array(config.mcp_skip).empty?
       end
 
+      def require_tool_files(config)
+        Array(config.tools&.paths).each do |path|
+          expanded = File.expand_path(path)
+          if File.exist?(expanded)
+            require expanded
+          else
+            $stderr.puts "Warning: Tool file not found: #{path}"
+          end
+        rescue LoadError, StandardError => e
+          $stderr.puts "Warning: Failed to load tool '#{path}': #{e.message}"
+        end
+      end
+
+      # Canonical --list-skills handler. Runs after config is built (so a -c
+      # config file's skills.dir is honored) and resolves skills the same way
+      # loading does, so what is listed is always loadable.
+      def handle_list_skills(config)
+        return unless config.respond_to?(:list_skills) && config.list_skills
+
+        puts AIA::SkillUtils.list_skills_markdown(config)
+        :early_exit
+      end
+
       def load_local_tools(config)
-        # Load required libraries (with gem activation and lazy-load triggering)
+        # Load required libraries
         Array(config.require_libs).each do |lib|
-          begin
-            Adapter::GemActivator.activate_gem_for_require(lib)
-            require lib
-            Adapter::GemActivator.trigger_tool_loading(lib)
-          rescue LoadError => e
-            warn "Warning: Failed to require '#{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
+          require lib
+        rescue LoadError => e
+          $stderr.puts "Warning: Failed to require '#{lib}': #{e.message}"
+          $stderr.puts "Hint: Make sure the gem is installed: gem install #{lib}"
+        rescue StandardError => e
+          $stderr.puts "Warning: Error in library '#{lib}': #{e.class} - #{e.message}"
         end
 
         # Load tool files
@@ -382,48 +376,49 @@ module AIA
           if File.exist?(expanded)
             require expanded
           else
-            warn "Warning: Tool file not found: #{path}"
+            $stderr.puts "Warning: Tool file not found: #{path}"
           end
         rescue LoadError, StandardError => e
-          warn "Warning: Failed to load tool '#{path}': #{e.message}"
+          $stderr.puts "Warning: Failed to load tool '#{path}': #{e.message}"
         end
 
         # Scan ObjectSpace for RubyLLM::Tool subclasses
         ObjectSpace.each_object(Class).select do |klass|
-          next false unless klass < RubyLLM::Tool
+          next false unless defined?(RubyLLM::Tool) && klass < RubyLLM::Tool
 
           begin
             klass.new
             true
-          rescue ArgumentError, LoadError, StandardError
+          rescue StandardError
             false
           end
         end
       end
 
       def first_sentences(text, count)
-        # Normalize whitespace: collapse newlines and multiple spaces
         normalized = text.gsub(/\s*\n\s*/, ' ').gsub(/\s{2,}/, ' ').strip
         sentences  = normalized.scan(/[^.!?]*[.!?]/)
         result     = sentences.first(count).join.strip
         result.empty? ? normalized : result
       end
 
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       def load_mcp_tools_grouped(config)
         servers = filter_mcp_servers(config)
         return {} if servers.empty?
 
-        # Suppress MCP logger noise during listing
         quiet_mcp_logger
 
         groups = {}
         default_timeout = 8_000
 
+        # rubocop:disable Metrics/BlockLength
         servers.each do |server|
-          name    = server[:name]    || server['name']
-          command = server[:command] || server['command']
-          args    = server[:args]    || server['args'] || []
-          env     = server[:env]     || server['env']  || {}
+          name      = AIA::Utility.server_name(server)
+          transport = server[:transport] || server['transport'] || {}
+          command   = transport[:command] || transport['command'] || server[:command] || server['command']
+          args      = transport[:args] || transport['args'] || server[:args] || server['args'] || []
+          env       = transport[:env] || transport['env'] || server[:env] || server['env'] || {}
 
           raw_timeout = server[:timeout] || server['timeout'] || default_timeout
           timeout = raw_timeout.to_i < 1000 ? (raw_timeout.to_i * 1000) : raw_timeout.to_i
@@ -461,26 +456,27 @@ module AIA
           rescue StandardError => e
             $stderr.puts " error: #{e.message}"
           end
+          # rubocop:enable Metrics/BlockLength
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
         groups
       end
+      # rubocop:enable Metrics/ModuleLength
 
       def quiet_mcp_logger
-        if defined?(RubyLLM::MCP) && RubyLLM::MCP.respond_to?(:config)
-          mcp_config = RubyLLM::MCP.config
-          if mcp_config.respond_to?(:logger=)
-            quiet = Logger.new(File::NULL)
-            mcp_config.logger = quiet
-          end
-        end
+        return unless defined?(RubyLLM::MCP) && RubyLLM::MCP.respond_to?(:config)
+        mcp_config = RubyLLM::MCP.config
+        return unless mcp_config.respond_to?(:logger=)
+        quiet = Logger.new(File::NULL)
+        mcp_config.logger = quiet
       end
 
       def handle_completion_script(config)
         return unless config.completion
 
         generate_completion_script(config.completion)
-        exit
+        :early_exit
       end
 
       def generate_completion_script(shell)
@@ -489,25 +485,18 @@ module AIA
         if File.exist?(script_path)
           puts File.read(script_path)
         else
-          warn "ERROR: The shell '#{shell}' is not supported or the completion script is missing."
+          $stderr.puts "ERROR: The shell '#{shell}' is not supported or the completion script is missing."
         end
       end
 
       def validate_final_prompt_requirements(config)
         chat_mode = config.flags.chat == true
         fuzzy_mode = config.flags.fuzzy == true
-        if !chat_mode && !fuzzy_mode && (config.prompt_id.nil? || config.prompt_id.empty?) && (config.context_files.nil? || config.context_files.empty?)
-          warn "Error: A prompt ID is required unless using --chat, --fuzzy, or providing context files. Use -h or --help for help."
-          exit 1
-        end
-      end
-
-      def configure_prompt_manager(config)
-        # PM v1.0.0 uses ERB parameters (<%= param %>) instead of regex-based extraction.
-        # parameter_regex is deprecated and ignored.
-        if config.prompts.parameter_regex
-          warn "Warning: --regex / parameter_regex is deprecated. PM v1.0.0 uses ERB parameters (<%= param %>)."
-        end
+        no_prompt = config.prompt_id.nil? || config.prompt_id.empty?
+        no_context = config.context_files.nil? || config.context_files.empty?
+        return unless !chat_mode && !fuzzy_mode && no_prompt && no_context
+        raise AIA::ConfigurationError,
+              "A prompt ID is required unless using --chat, --fuzzy, or providing context files. Use -h or --help for help."
       end
 
       def prepare_pipeline(config)
@@ -526,24 +515,19 @@ module AIA
 
           prompt_file_path = File.join(config.prompts.dir, "#{prompt_id}#{config.prompts.extname}")
           unless File.exist?(prompt_file_path)
-            warn "Error: Prompt ID '#{prompt_id}' does not exist at #{prompt_file_path}"
+            $stderr.puts "Error: Prompt ID '#{prompt_id}' does not exist at #{prompt_file_path}"
             and_exit = true
           end
         end
 
-        exit(1) if and_exit
+        raise AIA::ConfigurationError, "One or more prompt IDs do not exist." if and_exit
       end
 
-      # Dump configuration to file
-      #
-      # @param config [AIA::Config] the configuration to dump
-      # @param file [String] the file path to dump to
       def dump_config(config, file)
         ext = File.extname(file).downcase
 
         config_hash = config.to_h
 
-        # Remove runtime keys
         config_hash.delete(:prompt_id)
         config_hash.delete(:dump_file)
 
@@ -558,7 +542,6 @@ module AIA
         File.write(file, content)
         puts "Config successfully dumped to #{file}"
       end
-
     end
   end
 end