aia 2.0.0.0.pre.alpha → 2.0.0.0.pre.beta2

data/lib/aia/config/validator.rb

@@ -16,6 +16,7 @@ module AIA
       #
       # @param config [AIA::Config] the configuration to validate
       # @return [AIA::Config] the validated configuration
+      # :reek:TooManyStatements -- top-level validation pipeline: one named step per line, executed in fixed order
       def tailor(config)
         remaining_args = config.remaining_args&.dup || []
         config.remaining_args = nil
@@ -101,24 +102,25 @@ module AIA
 
       def handle_executable_prompt(config)
         return unless config.prompt_id.nil?
-        return unless config.context_files && !config.context_files.empty?
 
-        candidate = config.context_files.first
+        files = config.context_files
+        return unless files && !files.empty?
+
+        candidate = files.first
         return unless File.exist?(candidate) && File.readable?(candidate)
 
         first_line = File.open(candidate, &:readline).strip rescue nil
         return unless first_line&.start_with?('#!')
 
-        config.context_files.shift
+        files.shift
         config.executable_prompt_content = File.read(candidate).lines[1..].join
         config.prompt_id = '__EXECUTABLE_PROMPT__'
       end
 
       def handle_stdin_as_prompt(config)
         return unless config.prompt_id.nil?
-        return unless config.stdin_content && !config.stdin_content.strip.empty?
-
         content = config.stdin_content
+        return unless content && !content.strip.empty?
 
         if content.lines.first&.strip&.start_with?('#!')
           content = content.lines[1..].join
@@ -137,24 +139,24 @@ module AIA
       end
 
       def process_role_configuration(config)
-        role = config.prompts.role
+        prompts = config.prompts
+        role    = prompts.role
         return if role.nil? || role.empty?
 
-        roles_prefix = config.prompts.roles_prefix
+        roles_prefix = 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
+          role = "#{roles_prefix}/#{role}"
+          prompts.role = role
         end
 
-        config.prompts.roles_dir ||= File.join(config.prompts.dir, roles_prefix.to_s)
+        prompts.roles_dir ||= File.join(prompts.dir, roles_prefix.to_s)
 
         return if config.flags&.chat == true
 
         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 = ''
+        config.pipeline.prepend(role)
+        prompts.role = ''
       end
 
       def validate_plugins_dir(config)
@@ -172,9 +174,10 @@ module AIA
       end
 
       def normalize_boolean_flags(config)
-        normalize_boolean_flag(config.flags, :chat)
-        normalize_boolean_flag(config.flags, :fuzzy)
-        normalize_boolean_flag(config.flags, :consensus)
+        flags = config.flags
+        normalize_boolean_flag(flags, :chat)
+        normalize_boolean_flag(flags, :fuzzy)
+        normalize_boolean_flag(flags, :consensus)
       end
 
       def normalize_boolean_flag(flags_section, flag)
@@ -211,21 +214,19 @@ module AIA
         else
           label = mcp_filter_active?(config) ? "Active" : "Configured"
           puts "#{label} MCP servers:\n\n"
-          servers.each do |server|
-            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
+          servers.each { |server| print_mcp_server(McpServerConfig.from_hash(server)) }
         end
 
         :early_exit
       end
 
+      def print_mcp_server(server_config)
+        args_str = server_config.args.empty? ? '' : " #{server_config.args.join(' ')}"
+        puts "  #{server_config.name || '(unnamed)'}"
+        puts "    command: #{server_config.command || '(no command)'}#{args_str}"
+        puts
+      end
+
       def handle_list_tools(config)
         return unless config.list_tools
 
@@ -266,8 +267,8 @@ module AIA
       end
 
       def print_tool_terminal(tool, width, indent)
-        name = tool.respond_to?(:name) ? tool.name : tool.class.name
-        desc = tool.respond_to?(:description) ? tool.description.to_s.strip : ''
+        name = ToolIntrospection.tool_name(tool)
+        desc = ToolIntrospection.tool_description(tool).strip
 
         puts "  #{name}"
         unless desc.empty?
@@ -278,6 +279,7 @@ module AIA
         puts
       end
 
+      # :reek:TooManyStatements -- sequential markdown report: header, local tools section, one section per MCP server
       def list_tools_markdown(local_tools, mcp_tool_groups)
         total = local_tools.size + mcp_tool_groups.values.sum(&:size)
         sources = 1 + mcp_tool_groups.size
@@ -301,8 +303,8 @@ module AIA
       end
 
       def print_tool_markdown(tool)
-        name = tool.respond_to?(:name) ? tool.name : tool.class.name
-        desc = tool.respond_to?(:description) ? tool.description.to_s.strip : ''
+        name = ToolIntrospection.tool_name(tool)
+        desc = ToolIntrospection.tool_description(tool).strip
 
         puts "### `#{name}`"
         puts
@@ -360,7 +362,13 @@ module AIA
       end
 
       def load_local_tools(config)
-        # Load required libraries
+        require_configured_libs(config)
+        require_tool_files(config)
+        instantiable_tool_classes
+      end
+
+      # :reek:DuplicateMethodCall -- each e.message belongs to a different rescue clause exception; nothing to hoist
+      def require_configured_libs(config)
         Array(config.require_libs).each do |lib|
           require lib
         rescue LoadError => e
@@ -369,20 +377,10 @@ module AIA
         rescue StandardError => e
           $stderr.puts "Warning: Error in library '#{lib}': #{e.class} - #{e.message}"
         end
+      end
 
-        # Load tool files
-        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
-
-        # Scan ObjectSpace for RubyLLM::Tool subclasses
+      # Scan ObjectSpace for RubyLLM::Tool subclasses that can be instantiated.
+      def instantiable_tool_classes
         ObjectSpace.each_object(Class).select do |klass|
           next false unless defined?(RubyLLM::Tool) && klass < RubyLLM::Tool
 
@@ -402,65 +400,55 @@ module AIA
         result.empty? ? normalized : result
       end
 
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      # :reek:TooManyStatements -- per-server connect loop with progress prints on each outcome path
       def load_mcp_tools_grouped(config)
         servers = filter_mcp_servers(config)
         return {} if servers.empty?
 
         quiet_mcp_logger
 
-        groups = {}
-        default_timeout = 8_000
+        servers.each_with_object({}) do |server, groups|
+          server_config = McpServerConfig.from_hash(server)
+          $stderr.print "MCP: Connecting to #{server_config.name}..."
+          $stderr.flush
 
-        # rubocop:disable Metrics/BlockLength
-        servers.each do |server|
-          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'] || {}
+          tools = collect_server_tools(server_config)
+          if tools
+            groups[server_config.name] = tools
+            $stderr.puts " #{tools.size} tools"
+          else
+            $stderr.puts " failed"
+          end
+        rescue StandardError => e
+          $stderr.puts " error: #{e.message}"
+        end
+      end
 
-          raw_timeout = server[:timeout] || server['timeout'] || default_timeout
-          timeout = raw_timeout.to_i < 1000 ? (raw_timeout.to_i * 1000) : raw_timeout.to_i
-          timeout = [timeout, 30_000].min
+      # Connect to one server and return its tools, or nil when the client
+      # never comes alive.
+      def collect_server_tools(server_config)
+        mcp_add_client(server_config)
+        client = RubyLLM::MCP.clients[server_config.name]
+        client.start
+        return nil unless client.alive?
 
-          mcp_config = { command: command, args: Array(args) }
-          mcp_config[:env] = env unless env.empty?
+        client.tools rescue []
+      end
 
-          begin
-            $stderr.print "MCP: Connecting to #{name}..."
-            $stderr.flush
-
-            client = begin
-              RubyLLM::MCP.add_client(
-                name: name, transport_type: :stdio,
-                config: mcp_config, request_timeout: timeout, start: false
-              )
-            rescue ArgumentError
-              RubyLLM::MCP.add_client(
-                name: name, transport_type: :stdio,
-                config: mcp_config, start: false
-              )
-            end
-
-            client = RubyLLM::MCP.clients[name]
-            client.start
-
-            if client.alive?
-              server_tools = client.tools rescue []
-              groups[name] = server_tools
-              $stderr.puts " #{server_tools.size} tools"
-            else
-              $stderr.puts " failed"
-            end
-          rescue StandardError => e
-            $stderr.puts " error: #{e.message}"
-          end
-          # rubocop:enable Metrics/BlockLength
-        end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      def mcp_add_client(server_config)
+        mcp_config = { command: server_config.command, args: server_config.args }
+        mcp_config[:env] = server_config.env unless server_config.env.empty?
 
-        groups
+        RubyLLM::MCP.add_client(
+          name: server_config.name, transport_type: :stdio,
+          config: mcp_config, request_timeout: server_config.timeout_ms, start: false
+        )
+      rescue ArgumentError
+        # Older ruby_llm-mcp versions do not accept request_timeout
+        RubyLLM::MCP.add_client(
+          name: server_config.name, transport_type: :stdio,
+          config: mcp_config, start: false
+        )
       end
       # rubocop:enable Metrics/ModuleLength
 
@@ -500,9 +488,10 @@ module AIA
       end
 
       def prepare_pipeline(config)
-        return if config.prompt_id.nil? || config.prompt_id.empty? || config.prompt_id == config.pipeline.first
+        prompt_id = config.prompt_id
+        return if prompt_id.nil? || prompt_id.empty? || prompt_id == config.pipeline.first
 
-        config.pipeline.prepend(config.prompt_id)
+        config.pipeline.prepend(prompt_id)
       end
 
       def validate_pipeline_prompts(config)

data/lib/aia/config.rb

@@ -259,7 +259,7 @@ module AIA
     end
 
     # Convert config to hash (for dump, etc.)
-    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable-next Metrics/AbcSize
     def to_h
       {
         service: service.to_h,
@@ -287,11 +287,12 @@ module AIA
         context_files: context_files
       }
     end
-    # rubocop:enable Metrics/AbcSize
 
     private
 
     # Load a config file that REPLACES the user's personal config.
+    # :reek:TooManyStatements -- single case dispatch mapping YAML keys to typed config setters; one branch per key family
+    # :reek:DuplicateMethodCall -- Array(value) sits in mutually exclusive case branches; hoisting it would coerce hash-section values too
     def load_extra_config(path)
       path = File.expand_path(path)
 

data/lib/aia/content_extractor.rb

@@ -34,6 +34,7 @@ module AIA
     #
     # @param flow_result [SimpleFlow::Result]
     # @return [String]
+    # :reek:TooManyStatements -- one pass duck-types reply/content/duration into labeled sections
     def extract_network_content(flow_result)
       parts = []
       flow_result.context.each do |task_name, robot_result|
@@ -97,6 +98,7 @@ module AIA
     # @param tracker [SessionTracker, nil] to record the turn
     # @param decisions [Hash, nil] routing decisions for tracker
     # @return [String] the extracted content
+    # :reek:LongParameterList { max_params: 7 } -- presentation seam: each keyword is an independent optional aspect
     def present_result(result, ui_presenter:, streamed_content: nil, prompt: nil, elapsed: nil, tracker: nil, decisions: nil)
       content = streamed_content || extract_content(result)
 

data/lib/aia/cost_calculator.rb

@@ -13,6 +13,7 @@ module AIA
     # @param output_tokens [Integer]
     # @return [Hash] { available: true, total_cost:, input_cost:, output_cost: }
     #             or { available: false } when pricing is unavailable
+    # :reek:TooManyStatements -- linear price lookup: guard, registry fetch, per-direction cost math, result hash
     def self.calculate(model_id:, input_tokens:, output_tokens:)
       return { available: false } unless model_id && defined?(RubyLLM::Models)
 

data/lib/aia/debate_handler.rb

@@ -36,7 +36,7 @@ module AIA
     #
     # @param context [HandlerContext] — reads context.prompt
     # @return [String, nil] formatted debate results, or nil if not applicable
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    # :reek:TooManyStatements -- debate orchestration: per-round async fan-out, convergence check, tracking; stages share round state
     def handle(context)
       prompt = context.prompt
       return nil unless @robot.network?
@@ -55,33 +55,19 @@ module AIA
       rounds = []
 
       MAX_ROUNDS.times do |round|
+        round_no      = round + 1
         round_context = build_round_context(prompt, rounds)
 
-        round_results = Sync do
-          barrier = Async::Barrier.new
-          tasks = robots.map do |robot|
-            barrier.async do
-              @ui_presenter.display_info("  Round #{round + 1}: #{robot.name}...")
-              result  = robot.run(round_context, mcp: :inherit, tools: :inherit)
-              content = extract_content(result)
-              write_to_memory(round, robot.name, content)
-              { robot: robot.name, content: content }
-            rescue => e
-              FailedResponse.new(robot_name: robot.name, error_message: e.message)
-            end
-          end
-          barrier.wait
-          tasks.map(&:wait)
-        end
+        round_results = run_debate_round(robots, round_context, round, round_no)
 
-        raise DebateError, "All robots failed in round #{round + 1}" if
+        raise DebateError, "All robots failed in round #{round_no}" if
           round_results.all?(FailedResponse)
 
         previous = rounds.last
         rounds << round_results
 
         if converged?(round, round_results, previous)
-          @ui_presenter.display_info("  Converged in round #{round + 1}.")
+          @ui_presenter.display_info("  Converged in round #{round_no}.")
           break
         end
       end
@@ -94,10 +80,32 @@ module AIA
 
       format_rounds(rounds)
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
     private
 
+    # Run every robot once against the round context, concurrently.
+    # Returns one entry per robot: a result hash, or FailedResponse on error.
+    # :reek:TooManyStatements -- async fan-out with per-robot progress, memory write, and failure capture
+    def run_debate_round(robots, round_context, round, round_no)
+      Sync do
+        barrier = Async::Barrier.new
+        tasks = robots.map do |robot|
+          barrier.async do
+            name = robot.name
+            @ui_presenter.display_info("  Round #{round_no}: #{name}...")
+            result  = robot.run(round_context, mcp: :inherit, tools: :inherit)
+            content = extract_content(result)
+            write_to_memory(round, name, content)
+            { robot: name, content: content }
+          rescue => e
+            FailedResponse.new(robot_name: name, error_message: e.message)
+          end
+        end
+        barrier.wait
+        tasks.map(&:wait)
+      end
+    end
+
     def build_round_context(prompt, rounds)
       return prompt if rounds.empty?
 

data/lib/aia/delegate_handler.rb

@@ -27,6 +27,7 @@ module AIA
     #
     # @param context [HandlerContext] — reads context.prompt
     # @return [String, nil] combined results, or nil if not applicable
+    # :reek:TooManyStatements -- three-step delegation pipeline (decompose, plan, execute) sharing intermediate results
     def handle(context)
       prompt = context.prompt
       return nil unless @robot.network?
@@ -71,6 +72,7 @@ module AIA
 
     private
 
+    # :reek:TooManyStatements -- per-step loop: resolve assignee, announce, execute, record to memory and results
     def execute_steps(executor, prompt, plan, steps, robots)
       results = []
 
@@ -78,13 +80,15 @@ module AIA
         step_def = steps[i]
         assignee = robots.values.find { |r| r.name == step_def[:assignee] }
         assignee ||= robots.values.first
+        name  = assignee.name
+        title = step_def[:title]
 
-        @ui_presenter.display_info("  #{assignee.name}: #{step_def[:title]}...")
+        @ui_presenter.display_info("  #{name}: #{title}...")
 
         content = executor.execute(task, assignee, step_def, prompt, results)
 
-        write_to_memory(i, assignee.name, step_def[:title], content)
-        results << { robot: assignee.name, task: step_def[:title], content: content }
+        write_to_memory(i, name, title, content)
+        results << { robot: name, task: title, content: content }
       end
 
       results

data/lib/aia/directive.rb

@@ -68,6 +68,7 @@ module AIA
       # Application-level concern: formats help text using DIRECTIVE_PREFIX
       # and all registered directive subclasses.
 
+      # :reek:TooManyStatements -- sequential terminal report: header, one section per directive category, footer
       def help
         puts
         puts "Available Directives"
@@ -84,14 +85,7 @@ module AIA
           puts "-" * cat.length
 
           klass.directive_descriptions.each do |method_name, description|
-            aliases    = klass.directive_aliases[method_name] || []
-            alias_text = if aliases.any?
-                           " (aliases: #{aliases.map { |a| "#{DIRECTIVE_PREFIX}#{a}" }.join(', ')})"
-                         else
-                           ""
-                         end
-
-            puts "  #{DIRECTIVE_PREFIX}#{method_name}#{alias_text}"
+            puts "  #{DIRECTIVE_PREFIX}#{method_name}#{alias_text_for(klass, method_name)}"
             puts "      #{description}"
             puts
 
@@ -102,6 +96,14 @@ module AIA
         puts "\nTotal: #{total} directives available"
         ""
       end
+
+      # Format the "(aliases: ...)" suffix for a directive, or "" when it has none.
+      def alias_text_for(klass, method_name)
+        aliases = klass.directive_aliases[method_name] || []
+        return "" if aliases.empty?
+
+        " (aliases: #{aliases.map { |a| "#{DIRECTIVE_PREFIX}#{a}" }.join(', ')})"
+      end
     end
 
     private