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

data/lib/aia/directives/model_directives.rb

@@ -29,10 +29,29 @@ module AIA
     alias llms available_models
 
     desc "Compare responses from multiple models"
-    # rubocop:disable Metrics/MethodLength
     def compare(args, context_manager = nil)
-      return 'Error: No prompt provided for comparison' if args.empty?
+      prompt, models = parse_compare_args(args)
 
+      return report_error('Error: No prompt provided for comparison') unless prompt
+      return report_error('Error: No models specified. Use --models model1,model2,model3') if models.empty?
+
+      puts "\nComparing responses for: #{prompt}\n"
+      puts '=' * 80
+
+      models.each { |model_name| compare_with_model(model_name.strip, prompt) }
+
+      puts "\n" + ('=' * 80)
+      puts "\nComparison complete!"
+
+      ''
+    end
+    alias cmp compare
+
+    # --- helpers (no desc → not registered) ---
+
+    # Split a //compare arg list into [prompt, models]; the first non-flag
+    # token is the prompt, `--models a,b,c` supplies the model list.
+    def parse_compare_args(args)
       prompt = nil
       models = []
 
@@ -47,42 +66,26 @@ module AIA
         end
       end
 
-      return 'Error: No prompt provided for comparison' unless prompt
-      return 'Error: No models specified. Use --models model1,model2,model3' if models.empty?
-
-      puts "\nComparing responses for: #{prompt}\n"
-      puts '=' * 80
-
-      results = {}
-
-      models.each do |model_name|
-        model_name.strip!
-        puts "\n🤖 **#{model_name}:**"
-        puts '-' * 40
+      [prompt, models]
+    end
 
-        begin
-          chat = RubyLLM.chat(model: model_name)
-          response = chat.ask(prompt)
-          content = response.content
+    def compare_with_model(model_name, prompt)
+      puts "\n🤖 **#{model_name}:**"
+      puts '-' * 40
 
-          puts content
-          results[model_name] = content
-        rescue StandardError => e
-          error_msg = "Error with #{model_name}: #{e.message}"
-          puts error_msg
-          results[model_name] = error_msg
-        end
-      end
-
-      puts "\n" + ('=' * 80)
-      puts "\nComparison complete!"
-
-      ''
+      response = RubyLLM.chat(model: model_name).ask(prompt)
+      puts response.content
+    rescue StandardError => e
+      puts "Error with #{model_name}: #{e.message}"
     end
-    # rubocop:enable Metrics/MethodLength
-    alias cmp compare
 
-    # --- helpers (no desc → not registered) ---
+    # Log and print a directive error, then return nil so the chat loop
+    # skips forwarding it to the robot (an error is not conversational output).
+    def report_error(msg)
+      AIA::LoggerManager.aia_logger.error(msg)
+      puts msg
+      nil
+    end
 
     def show_local_models(current_models, positive_terms = nil, negative_terms = nil)
       require 'net/http'
@@ -105,110 +108,93 @@ module AIA
       end
     end
 
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    # :reek:TooManyStatements -- sequential terminal report: fetch, connection guards, filtered listing
     def show_ollama_models(api_base, positive_terms = nil, negative_terms = nil)
       positive_terms, negative_terms = normalized_model_search_terms(positive_terms, negative_terms)
 
-      begin
-        uri = URI("#{api_base}/api/tags")
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.open_timeout = 5
-        http.read_timeout = 5
-        response = http.request(Net::HTTP::Get.new(uri))
+      data = fetch_json("#{api_base}/api/tags")
+      if data.nil?
+        puts "❌ Cannot connect to Ollama at #{api_base}"
+        return
+      end
 
-        unless response.is_a?(Net::HTTPSuccess)
-          puts "❌ Cannot connect to Ollama at #{api_base}"
-          return
-        end
+      models = data['models'] || []
+      if models.empty?
+        puts "No Ollama models found"
+        return
+      end
 
-        data = JSON.parse(response.body)
-        models = data['models'] || []
+      puts "Ollama Models (#{api_base}):"
+      puts "-" * 60
 
-        if models.empty?
-          puts "No Ollama models found"
-          return
-        end
+      entries = models.map { |model| format_ollama_entry(model) }
+      print_filtered_entries(entries, positive_terms, negative_terms, "Ollama model(s) available")
+    rescue StandardError => e
+      puts "❌ Error fetching Ollama models: #{e.message}"
+    end
 
-        puts "Ollama Models (#{api_base}):"
-        puts "-" * 60
-
-        counter = 0
-        models.each do |model|
-          name = model['name']
-          size = model['size'] ? format_bytes(model['size']) : 'unknown'
-          modified = model['modified_at'] ? Time.parse(model['modified_at']).strftime('%Y-%m-%d') : 'unknown'
-
-          entry = "- ollama/#{name} (size: #{size}, modified: #{modified})"
-          entry_lc = entry.downcase
-
-          # entry_lc is a String; Array#intersect? would raise TypeError
-          show_it = positive_terms.empty? || positive_terms.any? { |q| entry_lc.include?(q) }
-          show_it &&= negative_terms.none? { |q| entry_lc.include?(q) }
-          if show_it
-            puts entry
-            counter += 1
-          end
-        end
+    def format_ollama_entry(model)
+      size     = model['size'] ? format_bytes(model['size']) : 'unknown'
+      modified = model['modified_at'] ? Time.parse(model['modified_at']).strftime('%Y-%m-%d') : 'unknown'
+      "- ollama/#{model['name']} (size: #{size}, modified: #{modified})"
+    end
 
-        puts
-        puts "#{counter} Ollama model(s) available"
-        puts
-      rescue StandardError => e
-        puts "❌ Error fetching Ollama models: #{e.message}"
-      end
+    # Fetch and parse JSON from a local model server; nil unless HTTP success.
+    def fetch_json(uri_string)
+      uri  = URI(uri_string)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.open_timeout = 5
+      http.read_timeout = 5
+      response = http.request(Net::HTTP::Get.new(uri))
+      return nil unless response.is_a?(Net::HTTPSuccess)
+
+      JSON.parse(response.body)
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-    def show_lms_models(api_base, positive_terms = nil, negative_terms = nil)
-      positive_terms, negative_terms = normalized_model_search_terms(positive_terms, negative_terms)
+    # The entry is a String; Array#intersect? would raise TypeError
+    def entry_matches?(entry_lc, positive_terms, negative_terms)
+      (positive_terms.empty? || positive_terms.any? { |q| entry_lc.include?(q) }) &&
+        negative_terms.none? { |q| entry_lc.include?(q) }
+    end
 
-      begin
-        uri = URI("#{api_base.gsub(%r{/v1/?$}, '')}/v1/models")
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.open_timeout = 5
-        http.read_timeout = 5
-        response = http.request(Net::HTTP::Get.new(uri))
+    def print_filtered_entries(entries, positive_terms, negative_terms, summary_label)
+      counter = 0
+      entries.each do |entry|
+        next unless entry_matches?(entry.downcase, positive_terms, negative_terms)
 
-        unless response.is_a?(Net::HTTPSuccess)
-          puts "❌ Cannot connect to LM Studio at #{api_base}"
-          return
-        end
+        puts entry
+        counter += 1
+      end
 
-        data = JSON.parse(response.body)
-        models = data['data'] || []
+      puts
+      puts "#{counter} #{summary_label}"
+      puts
+    end
 
-        if models.empty?
-          puts "No LM Studio models found"
-          return
-        end
+    # :reek:TooManyStatements -- sequential terminal report: fetch, connection guards, filtered listing
+    def show_lms_models(api_base, positive_terms = nil, negative_terms = nil)
+      positive_terms, negative_terms = normalized_model_search_terms(positive_terms, negative_terms)
 
-        puts "LM Studio Models (#{api_base}):"
-        puts "-" * 60
-
-        counter = 0
-        models.each do |model|
-          name = model['id']
-          entry = "- lms/#{name}"
-          entry_lc = entry.downcase
-
-          # entry_lc is a String; Array#intersect? would raise TypeError
-          show_it = positive_terms.empty? || positive_terms.any? { |q| entry_lc.include?(q) }
-          show_it &&= negative_terms.none? { |q| entry_lc.include?(q) }
-          if show_it
-            puts entry
-            counter += 1
-          end
-        end
+      data = fetch_json("#{api_base.gsub(%r{/v1/?$}, '')}/v1/models")
+      if data.nil?
+        puts "❌ Cannot connect to LM Studio at #{api_base}"
+        return
+      end
 
-        puts
-        puts "#{counter} LM Studio model(s) available"
-        puts
-      rescue StandardError => e
-        puts "❌ Error fetching LM Studio models: #{e.message}"
+      models = data['data'] || []
+      if models.empty?
+        puts "No LM Studio models found"
+        return
       end
+
+      puts "LM Studio Models (#{api_base}):"
+      puts "-" * 60
+
+      entries = models.map { |model| "- lms/#{model['id']}" }
+      print_filtered_entries(entries, positive_terms, negative_terms, "LM Studio model(s) available")
+    rescue StandardError => e
+      puts "❌ Error fetching LM Studio models: #{e.message}"
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
     def format_bytes(bytes)
       units = %w[B KB MB GB TB]
@@ -220,59 +206,53 @@ module AIA
       "%.1f %s" % [bytes.to_f / (1024**exp), units[exp]]
     end
 
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    # :reek:TooManyStatements -- sequential terminal report: header, filtered model listing, summary
     def show_rubyllm_models(positive_terms = nil, negative_terms = nil)
       positive_terms, negative_terms = normalized_model_search_terms(positive_terms, negative_terms)
 
       # expand comma-separated terms passed as a single token
-      if positive_terms.size == 1
-        positive_terms = positive_terms.first.split(',')
-      end
-
-      header = "\nAvailable LLMs"
-      header += " for #{positive_terms.join(' and ')}" if positive_terms.any?
-      header += " (excluding: #{negative_terms.join(', ')})" if negative_terms.any?
+      positive_terms = positive_terms.first.split(',') if positive_terms.size == 1
 
-      puts header + ':'
+      puts rubyllm_header(positive_terms, negative_terms)
       puts
 
       # modality terms (e.g. "text_to_text") trigger capability checks; the rest
       # are plain substring filters applied to the formatted entry string
-      q1, q2 = positive_terms.partition { |q| q.include?('_to_') }
+      modality_terms, substring_terms = positive_terms.partition { |q| q.include?('_to_') }
 
       counter = 0
-
       RubyLLM.models.all.each do |llm|
-        cw = llm.context_window
-        caps = llm.capabilities.join(',')
-        inputs = llm.modalities.input.join(',')
-        outputs = llm.modalities.output.join(',')
-        mode = "#{inputs} to #{outputs}"
-        in_1m = llm.pricing.text_tokens.standard.to_h[:input_per_million]
-        entry = "- #{llm.id} (#{llm.provider}) in: $#{in_1m} cw: #{cw} mode: #{mode} caps: #{caps}"
-
-        if positive_terms.empty? && negative_terms.empty?
-          counter += 1
-          puts entry
-          next
-        end
+        entry = format_rubyllm_entry(llm)
+        next unless rubyllm_entry_visible?(llm, entry, modality_terms, substring_terms, negative_terms)
 
-        show_it = true
-        q1.each { |q| show_it &&= llm.modalities.send("#{q}?") }
-        q2.each { |q| show_it &&= entry.include?(q) }
-        negative_terms.each { |q| show_it &&= !entry.downcase.include?(q) }
-
-        if show_it
-          counter += 1
-          puts entry
-        end
+        counter += 1
+        puts entry
       end
 
       puts if counter.positive?
       puts "#{counter} LLMs matching your query"
       puts
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+    def rubyllm_header(positive_terms, negative_terms)
+      header = "\nAvailable LLMs"
+      header += " for #{positive_terms.join(' and ')}" if positive_terms.any?
+      header += " (excluding: #{negative_terms.join(', ')})" if negative_terms.any?
+      header + ':'
+    end
+
+    def format_rubyllm_entry(llm)
+      modalities = llm.modalities
+      mode  = "#{modalities.input.join(',')} to #{modalities.output.join(',')}"
+      in_1m = llm.pricing.text_tokens.standard.to_h[:input_per_million]
+      "- #{llm.id} (#{llm.provider}) in: $#{in_1m} cw: #{llm.context_window} mode: #{mode} caps: #{llm.capabilities.join(',')}"
+    end
+
+    def rubyllm_entry_visible?(llm, entry, modality_terms, substring_terms, negative_terms)
+      modality_terms.all? { |q| llm.modalities.send("#{q}?") } &&
+        substring_terms.all? { |q| entry.include?(q) } &&
+        negative_terms.none? { |q| entry.downcase.include?(q) }
+    end
 
     def normalized_model_search_terms(positive_terms, negative_terms = nil)
       return parse_search_terms(Array(positive_terms)) if negative_terms.nil?

data/lib/aia/directives/trakflow_directives.rb

@@ -9,12 +9,12 @@ module AIA
     desc "Show TrakFlow ready tasks and project summary"
     def tasks(args, context_manager = nil)
       bridge = TrakFlowBridge.new
-      return "TrakFlow not available. Run 'tf init' to initialize a project." unless bridge.available?
+      return report_error("TrakFlow not available. Run 'tf init' to initialize a project.") unless bridge.available?
 
       if args.first == "summary"
-        bridge.project_summary || "No summary available."
+        bridge.project_summary || report_status("No summary available.")
       else
-        bridge.check_ready_tasks || "No ready tasks found."
+        bridge.check_ready_tasks || report_status("No ready tasks found.")
       end
     end
     alias tf tasks
@@ -22,23 +22,41 @@ module AIA
     desc "Create a TrakFlow plan from a description"
     def plan(args, context_manager = nil)
       bridge = TrakFlowBridge.new
-      return "TrakFlow not available. Run 'tf init' to initialize a project." unless bridge.available?
+      return report_error("TrakFlow not available. Run 'tf init' to initialize a project.") unless bridge.available?
 
       description = args.join(' ')
-      return "Usage: /plan <description>" if description.empty?
+      return report_error("Usage: /plan <description>") if description.empty?
 
-      bridge.create_task(description) || "Failed to create plan."
+      bridge.create_task(description) || report_error("Failed to create plan.")
     end
 
     desc "Create a TrakFlow task"
     def task(args, context_manager = nil)
       bridge = TrakFlowBridge.new
-      return "TrakFlow not available. Run 'tf init' to initialize a project." unless bridge.available?
+      return report_error("TrakFlow not available. Run 'tf init' to initialize a project.") unless bridge.available?
 
       title = args.join(' ')
-      return "Usage: /task <title>" if title.empty?
+      return report_error("Usage: /task <title>") if title.empty?
 
-      bridge.create_task(title) || "Failed to create task."
+      bridge.create_task(title) || report_error("Failed to create task.")
+    end
+
+    private
+
+    # Log and print a directive error, then return nil so the chat loop
+    # skips forwarding it to the robot (an error is not conversational output).
+    def report_error(msg)
+      AIA::LoggerManager.aia_logger.error(msg)
+      puts msg
+      nil
+    end
+
+    # Same as report_error, but for a non-error empty-result status
+    # (e.g. "no ready tasks found") rather than a failure.
+    def report_status(msg)
+      AIA::LoggerManager.aia_logger.info(msg)
+      puts msg
+      nil
     end
   end
 end

data/lib/aia/directives/utility_directives.rb

@@ -6,49 +6,24 @@ require 'word_wrapper'
 module AIA
   class UtilityDirectives < Directive
     desc "List available tools (optional filter by name or description substring)"
-    # rubocop:disable Metrics/AbcSize
     def tools(args = [], context_manager = nil)
-      indent = 4
-      spaces = " " * indent
-      width = TTY::Screen.width - indent - 2
-      filter = args.first&.downcase
-
+      raw_filter   = args.first
       loaded_tools = Array(AIA.config.loaded_tools) + all_mcp_tools
 
       if loaded_tools.empty?
         puts "No tools are available"
       else
-        tools_to_display = loaded_tools
-
-        if filter
-          tools_to_display = tools_to_display.select do |tool|
-            name = tool.respond_to?(:name) ? tool.name : tool.class.name
-            desc = tool.respond_to?(:description) ? tool.description.to_s : ""
-            "#{name} #{desc}".downcase.include?(filter)
-          end
-        end
-
+        tools_to_display = filter_tools(loaded_tools, raw_filter&.downcase)
         if tools_to_display.empty?
-          puts "No tools match the filter: #{args.first}"
+          puts "No tools match the filter: #{raw_filter}"
         else
-          puts
-          header = filter ? "Available Tools (filtered by '#{args.first}')" : "Available Tools"
-          puts header
-          puts "=" * header.length
-
-          tools_to_display.each do |tool|
-            name = tool.respond_to?(:name) ? tool.name : tool.class.name
-            puts "\n#{name}"
-            puts "-" * name.size
-            puts WordWrapper::MinimumRaggedness.new(width, tool.description).wrap.split("\n").map { |s| spaces + s + "\n" }.join
-          end
+          print_tools_report(tools_to_display, raw_filter)
         end
       end
       puts
 
       ''
     end
-    # rubocop:enable Metrics/AbcSize
 
     desc "List loaded plugin basenames"
     def plugins(args = [], context_manager = nil)
@@ -68,57 +43,22 @@ module AIA
     end
 
     desc "Show MCP server connection status and available tools"
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
     def mcp(args = [], context_manager = nil)
       connected = AIA.config&.connected_mcp_servers || []
       failed    = AIA.config&.failed_mcp_servers || []
-      defined_count = AIA::Utility.effective_mcp_server_names.size
 
       puts
       puts "MCP Server Status"
       puts "================="
-      puts "Defined: #{defined_count}  Connected: #{connected.size}  Failed: #{failed.size}"
+      puts "Defined: #{AIA::Utility.effective_mcp_server_names.size}  " \
+           "Connected: #{connected.size}  Failed: #{failed.size}"
       puts
 
-      if connected.any?
-        mcp_tools = all_mcp_tools
-
-        # Group tools by their MCP server name
-        tools_by_server = {}
-        connected.each { |name| tools_by_server[name] = [] }
-
-        mcp_tools.each do |tool|
-          server_name = tool.respond_to?(:mcp) ? tool.mcp : nil
-          if server_name && tools_by_server.key?(server_name)
-            tools_by_server[server_name] << tool
-          end
-        end
-
-        puts "Connected Servers:"
-        connected.each do |name|
-          tools = tools_by_server[name] || []
-          puts "  #{name} (#{tools.size} tools)"
-          tools.each do |tool|
-            tool_name = tool.respond_to?(:name) ? tool.name : tool.class.name
-            puts "    - #{tool_name}"
-          end
-        end
-        puts
-      end
-
-      if failed.any?
-        puts "Failed Servers:"
-        failed.each do |f|
-          name  = f[:name] || f['name']
-          error = f[:error] || f['error']
-          puts "  #{name}: #{error}"
-        end
-        puts
-      end
+      print_connected_servers(connected) if connected.any?
+      print_failed_servers(failed) if failed.any?
 
       ''
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
     desc "Show active robot configuration"
     def robots(args = [], context_manager = nil)
@@ -152,13 +92,72 @@ module AIA
 
     private
 
+    def filter_tools(tools, filter)
+      return tools unless filter
+
+      tools.select do |tool|
+        "#{ToolIntrospection.tool_name(tool)} #{ToolIntrospection.tool_description(tool)}"
+          .downcase.include?(filter)
+      end
+    end
+
+    def print_tools_report(tools_to_display, raw_filter)
+      puts
+      header = raw_filter ? "Available Tools (filtered by '#{raw_filter}')" : "Available Tools"
+      puts header
+      puts "=" * header.length
+
+      indent = 4
+      width  = TTY::Screen.width - indent - 2
+      tools_to_display.each { |tool| print_tool_entry(tool, width, " " * indent) }
+    end
+
+    def print_tool_entry(tool, width, spaces)
+      name = ToolIntrospection.tool_name(tool)
+      puts "\n#{name}"
+      puts "-" * name.size
+      puts WordWrapper::MinimumRaggedness.new(width, tool.description).wrap.split("\n").map { |s| spaces + s + "\n" }.join
+    end
+
+    def print_connected_servers(connected)
+      grouped = tools_by_server(connected, all_mcp_tools)
+
+      puts "Connected Servers:"
+      connected.each do |name|
+        tools = grouped[name] || []
+        puts "  #{name} (#{tools.size} tools)"
+        tools.each { |tool| puts "    - #{ToolIntrospection.tool_name(tool)}" }
+      end
+      puts
+    end
+
+    # Group MCP tools under the connected server each one came from.
+    def tools_by_server(connected, mcp_tools)
+      grouped = connected.to_h { |name| [name, []] }
+      mcp_tools.each do |tool|
+        server_name = tool.respond_to?(:mcp) ? tool.mcp : nil
+        grouped[server_name] << tool if server_name && grouped.key?(server_name)
+      end
+      grouped
+    end
+
+    def print_failed_servers(failed)
+      puts "Failed Servers:"
+      failed.each do |f|
+        puts "  #{f[:name] || f['name']}: #{f[:error] || f['error']}"
+      end
+      puts
+    end
+
+    # :reek:TooManyStatements -- mode classification plus sequential report of every crew member
     def show_network(network)
+      cfg = AIA.config
       robot_count = network.robot_count
-      mode = if AIA.config.flags.consensus
+      mode = if cfg.flags.consensus
                "Consensus"
-             elsif AIA.config.pipeline.length > 1
+             elsif cfg.pipeline.length > 1
                "Pipeline"
-             elsif AIA.config.models.length > 1
+             elsif cfg.models.length > 1
                "Parallel"
              else
                "Crew" # single-model session wrapped as a one-member crew
@@ -185,6 +184,7 @@ module AIA
       show_robot_detail(bot)
     end
 
+    # :reek:TooManyStatements -- one labeled line per robot attribute (model, wage, tool counts, role)
     def show_robot_detail(bot)
       puts "  #{bot.name}"