aia 1.1.1 → 2.0.0.0.pre.alpha

data/lib/aia/directives/model_directives.rb

@@ -4,14 +4,14 @@ module AIA
   class ModelDirectives < Directive
     desc "List all available AI models"
     def available_models(args = nil, context_manager = nil)
-      positive_terms, negative_terms = parse_search_terms(Array(args))
-
       current_models = AIA.config.models
 
       model_names = current_models.map do |m|
         m.respond_to?(:name) ? m.name : m.to_s
       end
 
+      positive_terms, negative_terms = parse_search_terms(Array(args))
+
       using_local_provider = model_names.any? { |m| m.start_with?('ollama/', 'lms/') }
 
       if using_local_provider
@@ -22,13 +22,14 @@ module AIA
 
       ""
     end
-    alias_method :am,         :available_models
-    alias_method :available,   :available_models
-    alias_method :models,      :available_models
-    alias_method :all_models,  :available_models
-    alias_method :llms,        :available_models
+    alias am available_models
+    alias available available_models
+    alias models available_models
+    alias all_models available_models
+    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?
 
@@ -73,19 +74,22 @@ module AIA
         end
       end
 
-      puts '\n' + '=' * 80
+      puts "\n" + ('=' * 80)
       puts "\nComparison complete!"
 
       ''
     end
-    alias_method :cmp, :compare
+    # rubocop:enable Metrics/MethodLength
+    alias cmp compare
 
     # --- helpers (no desc → not registered) ---
 
-    def show_local_models(current_models, positive_terms, negative_terms)
+    def show_local_models(current_models, positive_terms = nil, negative_terms = nil)
       require 'net/http'
       require 'json'
 
+      positive_terms, negative_terms = normalized_model_search_terms(positive_terms, negative_terms)
+
       puts "\nLocal LLM Models:"
       puts
 
@@ -101,10 +105,16 @@ module AIA
       end
     end
 
-    def show_ollama_models(api_base, positive_terms, negative_terms)
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    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")
-        response = Net::HTTP.get_response(uri)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.open_timeout = 5
+        http.read_timeout = 5
+        response = http.request(Net::HTTP::Get.new(uri))
 
         unless response.is_a?(Net::HTTPSuccess)
           puts "❌ Cannot connect to Ollama at #{api_base}"
@@ -129,11 +139,11 @@ module AIA
           modified = model['modified_at'] ? Time.parse(model['modified_at']).strftime('%Y-%m-%d') : 'unknown'
 
           entry = "- ollama/#{name} (size: #{size}, modified: #{modified})"
-          entry_down = entry.downcase
-
-          show_it = positive_terms.empty? || positive_terms.any? { |q| entry_down.include?(q) }
-          show_it &&= negative_terms.none? { |q| entry_down.include?(q) }
+          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
@@ -147,11 +157,18 @@ module AIA
         puts "❌ Error fetching Ollama models: #{e.message}"
       end
     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)
 
-    def show_lms_models(api_base, positive_terms, negative_terms)
       begin
         uri = URI("#{api_base.gsub(%r{/v1/?$}, '')}/v1/models")
-        response = Net::HTTP.get_response(uri)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.open_timeout = 5
+        http.read_timeout = 5
+        response = http.request(Net::HTTP::Get.new(uri))
 
         unless response.is_a?(Net::HTTPSuccess)
           puts "❌ Cannot connect to LM Studio at #{api_base}"
@@ -173,11 +190,11 @@ module AIA
         models.each do |model|
           name = model['id']
           entry = "- lms/#{name}"
-          entry_down = entry.downcase
-
-          show_it = positive_terms.empty? || positive_terms.any? { |q| entry_down.include?(q) }
-          show_it &&= negative_terms.none? { |q| entry_down.include?(q) }
+          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
@@ -191,28 +208,38 @@ module AIA
         puts "❌ Error fetching LM Studio models: #{e.message}"
       end
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
     def format_bytes(bytes)
-      units = ['B', 'KB', 'MB', 'GB', 'TB']
+      units = %w[B KB MB GB TB]
       return "0 B" if bytes.zero?
 
       exp = (Math.log(bytes) / Math.log(1024)).to_i
       exp = [exp, units.length - 1].min
 
-      "%.1f %s" % [bytes.to_f / (1024 ** exp), units[exp]]
+      "%.1f %s" % [bytes.to_f / (1024**exp), units[exp]]
     end
 
-    def show_rubyllm_models(positive_terms, negative_terms)
-      modality_terms = positive_terms.select { |q| q.include?('_to_') }
-      text_terms     = positive_terms.reject { |q| q.include?('_to_') }
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    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 ')}" unless positive_terms.empty?
-      header += " excluding: #{negative_terms.join(', ')}" unless negative_terms.empty?
+      header += " for #{positive_terms.join(' and ')}" if positive_terms.any?
+      header += " (excluding: #{negative_terms.join(', ')})" if negative_terms.any?
 
       puts header + ':'
       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_') }
+
       counter = 0
 
       RubyLLM.models.all.each do |llm|
@@ -223,12 +250,17 @@ module AIA
         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}"
-        entry_down = entry.downcase
+
+        if positive_terms.empty? && negative_terms.empty?
+          counter += 1
+          puts entry
+          next
+        end
 
         show_it = true
-        modality_terms.each { |q| show_it &&= llm.modalities.send("#{q}?") }
-        text_terms.each     { |q| show_it &&= entry_down.include?(q) }
-        negative_terms.each { |q| show_it &&= !entry_down.include?(q) }
+        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
@@ -236,9 +268,19 @@ module AIA
         end
       end
 
-      puts if counter > 0
+      puts if counter.positive?
       puts "#{counter} LLMs matching your query"
       puts
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+    def normalized_model_search_terms(positive_terms, negative_terms = nil)
+      return parse_search_terms(Array(positive_terms)) if negative_terms.nil?
+
+      [
+        Array(positive_terms).compact.map { |term| term.to_s.downcase },
+        Array(negative_terms).compact.map { |term| term.to_s.downcase }
+      ]
+    end
   end
 end

data/lib/aia/directives/trakflow_directives.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# lib/aia/directives/trakflow_directives.rb
+#
+# Chat directives for interacting with TrakFlow task tracking.
+
+module AIA
+  class TrakFlowDirectives < Directive
+    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?
+
+      if args.first == "summary"
+        bridge.project_summary || "No summary available."
+      else
+        bridge.check_ready_tasks || "No ready tasks found."
+      end
+    end
+    alias tf tasks
+
+    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?
+
+      description = args.join(' ')
+      return "Usage: /plan <description>" if description.empty?
+
+      bridge.create_task(description) || "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?
+
+      title = args.join(' ')
+      return "Usage: /task <title>" if title.empty?
+
+      bridge.create_task(title) || "Failed to create task."
+    end
+  end
+end

data/lib/aia/directives/utility_directives.rb

@@ -5,14 +5,16 @@ 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)"
+    # rubocop:disable Metrics/AbcSize
     def tools(args = [], context_manager = nil)
       indent = 4
       spaces = " " * indent
       width = TTY::Screen.width - indent - 2
       filter = args.first&.downcase
 
-      loaded_tools = AIA.config.loaded_tools || []
+      loaded_tools = Array(AIA.config.loaded_tools) + all_mcp_tools
+
       if loaded_tools.empty?
         puts "No tools are available"
       else
@@ -21,7 +23,8 @@ module AIA
         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)
+            desc = tool.respond_to?(:description) ? tool.description.to_s : ""
+            "#{name} #{desc}".downcase.include?(filter)
           end
         end
 
@@ -45,10 +48,95 @@ module AIA
 
       ''
     end
+    # rubocop:enable Metrics/AbcSize
+
+    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"
+    # 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
+
+      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
+
+      ''
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+    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
 
-    desc "Add instruction for concise responses"
-    def terse(args, context_manager = nil)
-      "" # DEPRECATED: terse mode has been removed
+      ''
     end
 
     desc "Display ASCII robot art"
@@ -61,5 +149,114 @@ module AIA
     def help(args = nil, context_manager = nil)
       AIA::Directive.help
     end
+
+    private
+
+    def show_network(network)
+      robot_count = network.robot_count
+      mode = if AIA.config.flags.consensus
+               "Consensus"
+             elsif AIA.config.pipeline.length > 1
+               "Pipeline"
+             elsif AIA.config.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
+
+    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