aia 1.1.1 → 2.0.0.0.pre.beta2

data/lib/aia/directives/utility_directives.rb

@@ -5,40 +5,19 @@ require 'word_wrapper'
 
 module AIA
   class UtilityDirectives < Directive
-    desc "List available tools (optional filter by name substring)"
+    desc "List available tools (optional filter by name or description substring)"
     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
 
-      loaded_tools = AIA.config.loaded_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
-            name.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
@@ -46,9 +25,58 @@ module AIA
       ''
     end
 
-    desc "Add instruction for concise responses"
-    def terse(args, context_manager = nil)
-      "" # DEPRECATED: terse mode has been removed
+    desc "List loaded plugin basenames"
+    def plugins(args = [], context_manager = nil)
+      loaded_plugins = Array(AIA.config&.loaded_plugins)
+
+      if loaded_plugins.empty?
+        puts "No plugins are loaded"
+      else
+        puts
+        puts "Loaded Plugins"
+        puts "=============="
+        loaded_plugins.each { |name| puts name }
+      end
+      puts
+
+      ''
+    end
+
+    desc "Show MCP server connection status and available tools"
+    def mcp(args = [], context_manager = nil)
+      connected = AIA.config&.connected_mcp_servers || []
+      failed    = AIA.config&.failed_mcp_servers || []
+
+      puts
+      puts "MCP Server Status"
+      puts "================="
+      puts "Defined: #{AIA::Utility.effective_mcp_server_names.size}  " \
+           "Connected: #{connected.size}  Failed: #{failed.size}"
+      puts
+
+      print_connected_servers(connected) if connected.any?
+      print_failed_servers(failed) if failed.any?
+
+      ''
+    end
+
+    desc "Show active robot configuration"
+    def robots(args = [], context_manager = nil)
+      client = AIA.client
+      unless client
+        puts "No active robots"
+        return ''
+      end
+
+      puts
+      if client.network?
+        show_network(client)
+      else
+        show_single_robot(client)
+      end
+      puts
+
+      ''
     end
 
     desc "Display ASCII robot art"
@@ -61,5 +89,174 @@ module AIA
     def help(args = nil, context_manager = nil)
       AIA::Directive.help
     end
+
+    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 cfg.flags.consensus
+               "Consensus"
+             elsif cfg.pipeline.length > 1
+               "Pipeline"
+             elsif cfg.models.length > 1
+               "Parallel"
+             else
+               "Crew" # single-model session wrapped as a one-member crew
+             end
+
+      header = "Active Robots"
+      puts header
+      puts "=" * header.length
+      noun = robot_count == 1 ? "robot" : "robots"
+      puts "Mode: #{mode} (#{robot_count} #{noun})"
+
+      network.crew.each do |bot|
+        puts
+        show_robot_detail(bot)
+      end
+    end
+
+    def show_single_robot(bot)
+      header = "Active Robot"
+      puts header
+      puts "=" * header.length
+      puts "Mode: Single"
+      puts
+      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}"
+
+      model_name = bot.model || 'unknown'
+      provider = bot.respond_to?(:provider) ? bot.provider : nil
+      provider ||= chat_provider(bot)
+      model_line = provider ? "#{model_name} (#{provider})" : model_name
+      puts "    Model:    #{model_line}"
+      puts "    Wage:     #{wage_for(model_name)}"
+
+      local_count = Array(bot.local_tools).size
+      mcp_count = Array(bot.mcp_tools).size
+      total = local_count + mcp_count
+      tool_parts = []
+      tool_parts << "#{local_count} local" if local_count.positive?
+      tool_parts << "#{mcp_count} mcp" if mcp_count.positive?
+      puts "    Tools:    #{total} (#{tool_parts.join(', ')})" if total.positive?
+      puts "    Tools:    none" if total.zero?
+
+      role = role_for(bot)
+      puts "    Role:     #{role}"
+    end
+
+    # Cost per 1K tokens (price_per_million * 1000 / 1_000_000)
+    def wage_for(model_name)
+      model_info = RubyLLM::Models.find(model_name)
+      input  = model_info&.input_price_per_million
+      output = model_info&.output_price_per_million
+      return 'N/A' unless input && output
+
+      in_per_k  = input  * 1000.0 / 1_000_000
+      out_per_k = output * 1000.0 / 1_000_000
+      "$#{'%.4f' % in_per_k} in / $#{'%.4f' % out_per_k} out per 1K tokens"
+    rescue StandardError
+      'N/A'
+    end
+
+    def chat_provider(bot)
+      bot.chat_provider
+    rescue StandardError
+      nil
+    end
+
+    def role_for(bot)
+      spec = AIA.config.models.find { |s| s.name == bot.model }
+      if spec&.role?
+        spec.role
+      else
+        "(default)"
+      end
+    end
+
+    # Retrieve MCP tools from robot or first robot in a Network.
+    # Falls back to RubyLLM::MCP.clients for tools registered by shared_tools
+    # or other gems that use RubyLLM::MCP.add_client directly.
+    def all_mcp_tools
+      robot = AIA.client
+      if robot
+        if robot.respond_to?(:mcp_tools) && robot.mcp_tools&.any?
+          return Array(robot.mcp_tools)
+        end
+
+        first_robot = robot.chief
+        if first_robot.respond_to?(:mcp_tools) && first_robot.mcp_tools&.any?
+          return Array(first_robot.mcp_tools)
+        end
+      end
+
+      # Fall back to RubyLLM::MCP clients (shared_tools and other gems
+      # that register MCP servers via RubyLLM::MCP.add_client)
+      return [] unless defined?(RubyLLM::MCP)
+      RubyLLM::MCP.clients.values.flat_map(&:tools)
+    end
   end
 end

data/lib/aia/directives/web_and_file_directives.rb

@@ -2,126 +2,88 @@
 
 require 'faraday'
 require 'clipboard'
-require 'yaml'
-require 'io/console'
-require 'word_wrapper'
 
 module AIA
   class WebAndFileDirectives < Directive
     include AIA::SkillUtils
+
     PUREMD_API_KEY = ENV.fetch('PUREMD_API_KEY', nil)
 
     desc "Fetch and include content from a webpage"
+    # :reek:TooManyStatements -- guard, fetch via pure.md, then success/error reporting in one flow
     def webpage(args, _context_manager = nil)
       if PUREMD_API_KEY.nil?
-        'ERROR: PUREMD_API_KEY is required in order to include a webpage'
-      else
-        url = args.shift.to_s.strip
-        puremd_url = "https://pure.md/#{url}"
+        msg = 'ERROR: PUREMD_API_KEY is required in order to include a webpage'
+        AIA::LoggerManager.aia_logger.error(msg)
+        puts msg
+        return nil
+      end
 
-        response = Faraday.get(puremd_url) do |req|
-          req.headers['x-puremd-api-token'] = PUREMD_API_KEY
-        end
+      url = args.shift.to_s.strip
+      puremd_url = "https://pure.md/#{url}"
 
-        if 200 == response.status
-          response.body
-        else
-          "Error: Status was #{response.status}\n#{ap response}"
-        end
+      response = Faraday.get(puremd_url) do |req|
+        req.headers['x-puremd-api-token'] = PUREMD_API_KEY
       end
+
+      return response.body if response.status == 200
+
+      msg = "Error: Fetching #{url} returned status #{response.status}"
+      AIA::LoggerManager.aia_logger.error(msg)
+      puts msg
+      nil
     end
-    alias_method :website, :webpage
-    alias_method :web,     :webpage
+    alias website webpage
+    alias web webpage
 
     desc "List available AIA skills"
+    # :reek:TooManyStatements -- sequential listing: directory guard, term filtering, per-skill output
     def skills(args = [], _context_manager = nil)
       dir = aia_skills_dir
-
       unless Dir.exist?(dir)
         puts "No skills directory found at #{dir}"
         return nil
       end
 
       positive_terms, negative_terms = parse_search_terms(Array(args))
+      entries = matching_skill_ids(dir, positive_terms, negative_terms)
 
-      skill_dirs = Dir.children(dir)
-                      .select { |e| Dir.exist?(File.join(dir, e)) }
-                      .sort
-
-      if skill_dirs.empty?
-        puts "No skills found in #{dir}"
-        return nil
-      end
-
-      skill_data = skill_dirs.filter_map do |name|
-        fm = parse_front_matter(File.join(dir, name, 'SKILL.md'))
-        text = "#{name} #{fm.values.join(' ').downcase}"
-        pos_ok = positive_terms.empty? || positive_terms.all? { |t| text.include?(t) }
-        neg_ok = negative_terms.none? { |t| text.include?(t) }
-        [name, fm] if pos_ok && neg_ok
-      end
-
-      if skill_data.empty?
-        puts "No skills matching your query"
+      if entries.empty?
+        all_terms = positive_terms + negative_terms
+        puts all_terms.empty? ? "No skills found in #{dir}" : "No skills matched: #{Array(args).join(' ')}"
         return nil
       end
 
-      width = terminal_width
-      puts "\nAvailable Skills (#{dir}):"
-      puts "=" * [width, 60].min
-
-      skill_data.each do |name, fm|
-        display_name = fm['name'] || name
-        desc_text = fm['description'].to_s.strip
-        puts "\n  #{display_name}"
-        unless desc_text.empty?
-          puts WordWrapper::MinimumRaggedness.new(width - 4, desc_text).wrap
-            .split("\n").map { |l| "    #{l}" }.join("\n")
-        end
-      end
+      wrap_width = terminal_width - 2
+      entries.each { |skill_id| print_skill_entry(dir, skill_id, wrap_width) }
 
-      puts "\nTotal: #{skill_data.size} skill#{'s' if skill_data.size != 1}"
       nil
     end
 
-    desc "Include an AIA skill from the skills directory"
+    desc "Include an AIA skill from the configured skills directory"
     def skill(args = [], _context_manager = nil)
       args = Array(args)
       skill_name = args.first&.strip
-
       if skill_name.nil? || skill_name.empty?
-        warn "Error: /skill requires a skill name. Use /skills to list available skills."
-        AIA::LoggerManager.aia_logger.error("/skill requires a skill name")
-        return nil
+        return report_skill_error("Error: /skill requires a skill name. Use /skills to list available skills.")
       end
 
       dir = aia_skills_dir
-
-      unless Dir.exist?(dir)
-        warn "Error: Skills directory not found at #{dir}"
-        AIA::LoggerManager.aia_logger.error("Skills directory not found at #{dir}")
-        return nil
-      end
-
       skill_dir = find_skill_dir(skill_name, dir)
       unless skill_dir
-        if path_based_id?(skill_name)
-          warn "Error: No skill directory found at '#{File.expand_path(skill_name)}'. Use /skills to list available skills."
-          AIA::LoggerManager.aia_logger.error("No skill directory found at '#{File.expand_path(skill_name)}'")
-        else
-          warn "Error: No skill matching '#{skill_name}' found in #{dir}. Use /skills to list available skills."
-          AIA::LoggerManager.aia_logger.error("No skill matching '#{skill_name}' found in #{dir}")
-        end
-        return nil
+        return report_skill_error("Error: No skill matching '#{skill_name}' found in #{dir}. Use /skills to list available skills.")
       end
 
       return File.read(skill_dir) if File.file?(skill_dir)
 
       skill_path = File.join(skill_dir, 'SKILL.md')
       unless File.exist?(skill_path)
-        warn "Error: Skill directory '#{File.basename(skill_dir)}' has no SKILL.md. Use /skills to list available skills."
-        AIA::LoggerManager.aia_logger.error("Skill directory '#{File.basename(skill_dir)}' has no SKILL.md")
-        return nil
+        msg = if path_based_id?(skill_name)
+                "Error: No skill matching '#{skill_name}' found in #{dir}. Use /skills to list available skills."
+              else
+                "Error: Skill '#{File.basename(skill_dir)}' has no SKILL.md in #{dir}."
+              end
+        return report_skill_error(msg)
       end
 
       File.read(skill_path)
@@ -132,21 +94,108 @@ module AIA
       content = Clipboard.paste
       content.to_s
     rescue StandardError => e
-      "Error: Unable to paste from clipboard - #{e.message}"
+      msg = "Error: Unable to paste from clipboard - #{e.message}"
+      AIA::LoggerManager.aia_logger.error(msg)
+      puts msg
+      nil
     end
-    alias_method :clipboard, :paste
+    alias clipboard paste
 
     private
 
+    # Skill directories under dir with a SKILL.md whose front matter passes
+    # the positive/negative term filters, sorted.
+    def matching_skill_ids(dir, positive_terms, negative_terms)
+      skill_dirs = Dir.children(dir).select do |e|
+        File.directory?(File.join(dir, e)) &&
+          File.exist?(File.join(dir, e, 'SKILL.md'))
+      end
+
+      skill_dirs.select do |e|
+        next true if positive_terms.empty? && negative_terms.empty?
+        text = read_front_matter_text(File.join(dir, e, 'SKILL.md'))
+        # text is a String; Array#intersect? would raise TypeError
+        positive_terms.all? { |t| text.include?(t) } &&
+          negative_terms.none? { |t| text.include?(t) }
+      end.sort
+    end
+
+    def print_skill_entry(dir, skill_id, wrap_width)
+      fm = parse_skill_front_matter(File.join(dir, skill_id, 'SKILL.md'))
+      name        = fm['name']        || ''
+      description = fm['description'] || '(no description)'
+      puts "#{skill_id}: #{name}"
+      puts word_wrap(description, width: wrap_width, indent: '  ')
+      puts
+    end
+
+    # Log and print a /skill error message; returns nil so callers can
+    # `return report_skill_error(msg)` from any guard.
+    def report_skill_error(msg)
+      AIA::LoggerManager.aia_logger.error(msg)
+      puts msg
+      nil
+    end
+
+    # Resolve the AIA skills directory from config, env vars, or defaults.
     def aia_skills_dir
-      AIA.config.skills.dir
+      skills = AIA.respond_to?(:config) ? AIA.config&.skills : nil
+      return skills.dir if skills.respond_to?(:dir) && skills.dir
+
+      ENV.fetch('AIA_SKILLS__DIR', File.expand_path('~/.prompts/skills'))
     end
 
     def terminal_width
+      require 'io/console'
       IO.console&.winsize&.last || 80
     rescue StandardError
       80
     end
 
+    # Word-wrap text to width, prefixing every line with indent.
+    def word_wrap(text, width:, indent: '')
+      return "#{indent}#{text}" if text.length <= width
+
+      words = text.split
+      lines = []
+      line  = +''
+
+      words.each do |word|
+        if line.empty?
+          line = word
+        elsif line.length + 1 + word.length <= width
+          line << ' ' << word
+        else
+          lines << line
+          line = word
+        end
+      end
+      lines << line unless line.empty?
+
+      lines.map { |l| "#{indent}#{l}" }.join("\n")
+    end
+
+    def read_front_matter_text(skill_md_path)
+      content = File.read(skill_md_path)
+      return '' unless content.start_with?("---")
+
+      end_pos = content.index("---", 3)
+      return '' unless end_pos
+
+      content[3...end_pos].downcase
+    end
+
+    def parse_skill_front_matter(skill_md_path)
+      require 'yaml'
+      content = File.read(skill_md_path)
+      return {} unless content.start_with?("---")
+
+      end_pos = content.index("---", 3)
+      return {} unless end_pos
+
+      yaml_text = content[3...end_pos].strip
+      parsed    = YAML.safe_load(yaml_text, symbolize_names: false) rescue {}
+      parsed.is_a?(Hash) ? parsed : {}
+    end
   end
 end

data/lib/aia/errors.rb

@@ -21,4 +21,19 @@ module AIA
 
   # Raised for directive parsing or execution failures
   class DirectiveError < Error; end
+
+  # Raised for crew recruit/drop failures
+  class CrewError < Error; end
+
+  # Raised when a quality gate blocks prompt execution
+  class GateError < Error; end
+
+  # Raised when all lead agents fail in LayeredOrchestrator
+  class OrchestratorError < Error; end
+
+  # Raised when all robots fail in a single DebateHandler round
+  class DebateError < Error; end
+
+  # Raised when all sub-tasks fail in SpecialModeHandler decompose mode
+  class DecomposeError < Error; end
 end

data/lib/aia/fact_asserter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# lib/aia/fact_asserter.rb
+#
+# Thin adapter that extracts tool_name and tool_description from a tool object.
+# Replaces the KBS FactAsserter with a plain Ruby implementation that reads
+# the standard .name and .description interface common to all AIA tool objects.
+
+module AIA
+  class FactAsserter
+    # Extract the tool's name as a non-nil String.
+    #
+    # @param tool [Object] any object that responds to .name
+    # @return [String]
+    def tool_name(tool)
+      String(tool.respond_to?(:name) ? tool.name : "").strip
+    end
+
+    # Extract the tool's description as a non-nil String.
+    #
+    # @param tool [Object] any object that responds to .description
+    # @return [String]
+    def tool_description(tool)
+      String(tool.respond_to?(:description) ? tool.description : "").strip
+    end
+  end
+end

data/lib/aia/fzf.rb

@@ -3,7 +3,6 @@
 
 require 'shellwords'
 require 'open3'
-require 'tempfile'
 
 class AIA::Fzf
   DEFAULT_PARAMETERS = %w[
@@ -12,19 +11,18 @@ class AIA::Fzf
     --prompt='Search term: '
     --delimiter :
     --preview-window=down:50%:wrap
-  ]
+  ].freeze
 
   attr_reader :list, :directory, :query, :subject, :prompt, :extension, :command
 
   def initialize(
-      list:,          # Array of Strings (basenames of files w/o extension)
-      directory:,     # Parent directory of the list items
-      query:      '', # String, the thing be searched for
-      subject:    'Prompt IDs', # or 'Role Names'
-      prompt:     'Select one:',
-      extension:  '.md'
-    )
-
+    list:,          # Array of Strings (basenames of files w/o extension)
+    directory:,     # Parent directory of the list items
+    query:      '', # String, the thing be searched for
+    subject:    'Prompt IDs', # or 'Role Names'
+    prompt:     'Select one:',
+    extension:  '.md'
+  )
     @list       = list
     @directory  = directory
     @query      = query
@@ -35,7 +33,6 @@ class AIA::Fzf
     build_command
   end
 
-
   def build_command
     fzf_options = DEFAULT_PARAMETERS.dup
     escaped_dir = Shellwords.escape(directory)
@@ -47,29 +44,10 @@ class AIA::Fzf
     @fzf_args = fzf_options
   end
 
-
   def run
     input = list.join("\n")
-    selected, status = Open3.capture2('fzf', *@fzf_args, stdin_data: input)
-
+    selected, _status = Open3.capture2('fzf', *@fzf_args, stdin_data: input)
     selected.strip.empty? ? nil : selected.strip
-  ensure
-    unlink_tempfile
-  end
-
-  ##############################################
-  private
-
-  def tempfile_path
-    @tempfile ||= Tempfile.new('fzf-input').tap do |file|
-      list.each { |item| file.puts item }
-      file.close
-    end
-    @tempfile.path
-  end
-
-  def unlink_tempfile
-    @tempfile&.unlink
   end
 end
 

data/lib/aia/handler_context.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# lib/aia/handler_context.rb
+#
+# Value object passed to every handler's handle(context) method.
+# All fields are optional (default nil) — each handler reads only what it needs.
+
+module AIA
+  HandlerContext = Struct.new(
+    :robot,           # RobotLab::Robot or Network for the current turn
+    :prompt,          # String — the user prompt
+    :config,          # AIA config object
+    :specialist_type, # String or nil — explicit specialist role for SpawnHandler
+    :spawn_spec,      # Hash or nil — explicit {name:, model:, provider:, system_prompt:} for SpawnHandler
+    keyword_init: true
+  )
+end