aia 1.1.1 → 2.0.0.0.pre.beta2

data/lib/aia/utility.rb

@@ -1,118 +1,167 @@
 # lib/aia/utility.rb
 
-require 'word_wrapper'      # Pure ruby word wrapping
+require 'word_wrapper'
+require 'simple_flow'
+require 'trak_flow'
+require 'tty-table'
+begin
+  require 'ruby_llm/mcp'
+rescue LoadError, StandardError
+  # ruby_llm-mcp may not be installed
+end
+
+require_relative 'mcp_utility'
+require_relative 'tool_utility'
 
 module AIA
-  class Utility
+  module Utility
     class << self
-      def tools?
-        AIA.config&.tool_names && !AIA.config.tool_names.empty?
+      include MCPUtility
+      include ToolUtility
+
+      def models_last_refresh
+        aia_dir = AIA.config&.paths&.aia_dir
+        return nil if aia_dir.nil?
+        models_file = File.join(File.expand_path(aia_dir), 'models.json')
+        File.mtime(models_file).strftime('%Y-%m-%d %H:%M')
+      rescue Errno::ENOENT
+        nil
       end
 
-      def user_tools?
-        AIA.config&.tools&.paths && !AIA.config.tools.paths.empty?
+      def build_crew_line
+        names = robot_names
+        return '' if names.empty?
+        "Today's crew: #{format_crew_mentions(names)}"
       end
 
-      def mcp_servers?
-        AIA.config&.mcp_servers && !AIA.config.mcp_servers.empty?
+      def robot
+        art = [
+          '       ,      ,',
+          '       (\____/)',
+          '        (_oo_)',
+          '         (O)',
+          '       __|||__    \)',
+          '     [/ Tobor \]  /',
+          '    / \_______/ \/',
+          '   /    /___\\',
+          '  (\   /_____\\',
+          '     :::     :::',
+          '     :::     :::'
+        ].join("\n")
+
+        art_width   = art.lines.map(&:length).max
+        info_width  = [TTY::Screen.width - art_width - 4, 30].max
+        label_width = 7  # "Models:" is the widest label
+        value_width = [info_width - label_width - 1, 20].max
+
+        header = "AIA v#{AIA::VERSION} is Online"
+
+        inner = TTY::Table.new(banner_detail_rows)
+        details = inner.render(:basic, multiline: true,
+                               column_widths: [label_width, value_width],
+                               alignments: %i[right left])
+
+        outer = TTY::Table.new([[art, "#{header}\n\n#{details}"]])
+        puts "\n#{outer.render(:basic, multiline: true, column_widths: [art_width, info_width], padding: [0, 1, 0, 0])}"
       end
 
-      # Returns only successfully connected MCP server names
-      def mcp_server_names
-        # Use connected_mcp_servers if available (populated during MCP setup)
-        connected = AIA.config&.connected_mcp_servers
-        return connected if connected && !connected.empty?
+      private
 
-        # Fallback to configured servers if connection status not yet known
-        return [] unless mcp_servers?
-        AIA.config.mcp_servers.map { |s| s[:name] || s["name"] }.compact
+      def robot_names
+        client = AIA.client
+        return [] unless client
+        client.crew.map(&:name)
       end
 
-      # Returns true if there are any connected MCP servers
-      def connected_mcp_servers?
-        connected = AIA.config&.connected_mcp_servers
-        connected && !connected.empty?
+      def format_crew_mentions(names)
+        names.map { |n| "@#{n.downcase}" }.join(', ')
       end
 
-      # Returns list of failed MCP servers with their errors
-      def failed_mcp_servers
-        AIA.config&.failed_mcp_servers || []
+      def banner_detail_rows
+        [
+          ['Models:', banner_models],
+          ['DB:',     banner_db],
+          ['Libs:',   banner_libs],
+          ['Tools:',  banner_tools],
+          ['MCP:',    banner_mcp],
+          ['Crew:',   banner_crew]
+        ]
       end
 
-      def supports_tools?
-        AIA.client&.model&.supports_functions? || false
+      def banner_models
+        models = AIA.config&.models
+        return 'unknown-model' if models.nil? || models.empty?
+        models.map do |spec|
+          case spec
+          when AIA::ModelSpec then spec.name
+          when Hash           then spec[:name] || spec['name'] || spec.to_s
+          else                     spec.to_s
+          end
+        end.join(', ')
       end
 
-      # Returns the last refresh date from models.json modification time
-      def models_last_refresh
-        aia_dir = AIA.config&.paths&.aia_dir
-        return nil if aia_dir.nil?
-
-        models_file = File.join(File.expand_path(aia_dir), 'models.json')
-        return nil unless File.exist?(models_file)
-
-        File.mtime(models_file).strftime('%Y-%m-%d %H:%M')
+      def banner_libs
+        parts = ["ruby_llm v#{RubyLLM::VERSION}"]
+        parts << "ruby_llm-mcp v#{RubyLLM::MCP::VERSION}" if defined?(RubyLLM::MCP::VERSION)
+        parts << "robot_lab v#{RobotLab::VERSION}"         if defined?(RobotLab::VERSION)
+        parts << "simple_flow v#{SimpleFlow::VERSION}"     if defined?(SimpleFlow::VERSION)
+        parts << "trak_flow v#{TrakFlow::VERSION}"         if defined?(TrakFlow::VERSION)
+        parts << "typed_bus v#{TypedBus::VERSION}"         if defined?(TypedBus::VERSION)
+        parts.join(', ')
       end
 
-      # Displays the AIA robot ASCII art
-      # Yes, its slightly frivolous but it does contain some
-      # useful configuration information.
-      def robot
-        indent  = 18
-        spaces  = " "*indent
-        width   = TTY::Screen.width - indent - 2
-
-        mcp_version = defined?(RubyLLM::MCP::VERSION) ? " MCP v" + RubyLLM::MCP::VERSION : ''
-
-        # Extract model names from config (handles ModelSpec objects or Hashes)
-        model_display = if AIA.config&.models && !AIA.config.models.empty?
-          models = AIA.config.models
-          models.map do |spec|
-            if spec.is_a?(AIA::ModelSpec)
-              spec.name
-            elsif spec.is_a?(Hash)
-              spec[:name] || spec['name'] || spec.to_s
-            else
-              spec.to_s
-            end
-          end.join(', ')
+      def banner_tools
+        count = total_tool_count
+        if count.positive?
+          "#{count} #{count == 1 ? 'tool' : 'tools'} loaded"
         else
-          'unknown-model'
+          'none loaded'
         end
+      end
 
-        # Build MCP line based on connection status
-        mcp_line = if !mcp_servers?
-          ''  # No MCP servers configured
-        elsif connected_mcp_servers?
-          "MCP: #{mcp_server_names.join(', ')}"
-        else
-          "MCP: (none connected)"
-        end
+      def banner_mcp
+        connected = mcp_client_labels
+        failed    = failed_mcp_servers.map { |f| server_name(f) }
+        return '(none configured)' if connected.empty? && failed.empty?
+        parts = []
+        parts << connected.join(', ')           unless connected.empty?
+        parts << "FAILED: #{failed.join(', ')}" unless failed.empty?
+        parts.join(' | ')
+      end
 
-        puts <<-ROBOT
-
-       ,      ,
-       (\\____/) AI Assistant (v#{AIA::VERSION}) is Online
-        (_oo_)   #{model_display}#{supports_tools? ? ' (supports tools)' : ''}
-         (O)       using ruby_llm (v#{RubyLLM::VERSION}#{mcp_version})
-       __||__    \\) model db was last refreshed on
-     [/______\\]  /    #{models_last_refresh || 'unknown'}
-    / \\__AI__/ \\/      #{user_tools? ? 'I will also use your tools' : (tools? ? 'You can share my tools' : 'I did not bring any tools')}
-   /    /__\\              #{mcp_line}
-  (\\   /____\\   #{user_tools? && tools? ? 'My Toolbox contains:' : ''}
-        ROBOT
-        if user_tools? && tools?
-          tool_names = AIA.config.tool_names
-          if tool_names && !tool_names.to_s.empty?
-            puts WordWrapper::MinimumRaggedness.new(
-                width,
-                tool_names.to_s # String of tool names, comma separated
-              ).wrap
-              .split("\n")
-              .map{|s| spaces+s+"\n"}
-              .join
+      # Post-connection: connected_mcp_servers is the authoritative name list;
+      # mcp_server_tool_counts provides per-server tool counts.
+      # Pre-connection fallback: read live from RubyLLM::MCP.clients (--require clients).
+      # :reek:TooManyStatements -- authoritative post-connection labels with a live RubyLLM::MCP fallback before connection
+      def mcp_client_labels
+        cfg = AIA.config
+        return [] if cfg&.flags&.no_mcp
+
+        connected = cfg&.connected_mcp_servers
+        unless connected.nil?
+          counts = cfg&.mcp_server_tool_counts || {}
+          return connected.map do |name|
+            count = counts[name]
+            count ? "#{name}(#{count})" : name
           end
         end
+
+        return [] unless defined?(RubyLLM::MCP)
+        RubyLLM::MCP.clients.filter_map do |name, client|
+          count = client.tools.count rescue nil
+          "#{name}(#{count})" if count
+        end
+      end
+
+      def banner_db
+        refresh = models_last_refresh
+        refresh ? "refreshed #{refresh.gsub(' ', ' at ')}" : 'not yet refreshed'
+      end
+
+      def banner_crew
+        names = robot_names
+        return '' if names.empty?
+        format_crew_mentions(names)
       end
     end
   end

data/lib/aia/{history_manager.rb → variable_input_collector.rb}

@@ -1,15 +1,15 @@
-# lib/aia/history_manager.rb
+# lib/aia/variable_input_collector.rb
 
 require 'json'
 require 'fileutils'
 
 module AIA
-  class HistoryManager
+  class VariableInputCollector
     def initialize
       # No prompt dependency — just handles user input for parameter collection
     end
 
-
+    # :reek:TooManyStatements -- one Reline round-trip: question build, readline, Ctrl+D/empty fallbacks, prompt_proc restore
     def request_variable_value(variable_name:, default_value: nil)
       Reline::HISTORY.clear
 
@@ -28,24 +28,24 @@ module AIA
 
         if input.nil? # Ctrl+D
           return default_value if default_value
-          puts "\nParameter '#{variable_name}' is required."
-          exit(1)
+          raise AIA::Error, "Parameter '#{variable_name}' is required."
         end
 
         value = input.strip
         if value.empty?
           return default_value if default_value
-          puts "Parameter '#{variable_name}' is required."
-          exit(1)
+          raise AIA::Error, "Parameter '#{variable_name}' is required."
         end
 
         value
       rescue Interrupt
-        puts "\nVariable input interrupted."
-        exit(1)
+        raise AIA::Error, "Variable input interrupted."
       ensure
         Reline.line_editor.prompt_proc = original_prompt_proc
       end
     end
   end
+
+  # Backward-compatibility alias — prefer VariableInputCollector in new code.
+  HistoryManager = VariableInputCollector
 end

data/lib/aia/verification_network.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# lib/aia/verification_network.rb
+#
+# Self-review via consensus: two robots independently answer,
+# then a reconciler compares and produces a verified answer.
+
+module AIA
+  class VerificationNetwork
+    # Build a verification network for the given config.
+    #
+    # @param config the AIA configuration
+    # @return [RobotLab::Network] a consensus network with verifiers + reconciler
+    def self.build(config)
+      model = config.models.first
+      run_config = RobotFactory.build_run_config(config)
+      tools = ToolLoader.filtered_tools(config)
+      mcp = RobotFactory.mcp_server_configs(config)
+      model_id = model.internal_id
+
+      # rubocop:disable-next Metrics/BlockLength
+      RobotLab.create_network(name: "aia-verification") do
+        worker_a = RobotLab.build(
+          name:          "verifier-a",
+          model:         model_id,
+          system_prompt: "Answer the following question. Be thorough and precise.",
+          local_tools:   tools,
+          mcp_servers:   mcp,
+          config:        run_config
+        )
+        task :verify_a, worker_a, depends_on: :none
+
+        worker_b = RobotLab.build(
+          name:          "verifier-b",
+          model:         model_id,
+          system_prompt: "Answer the following question independently. " \
+                         "Focus on correctness and completeness.",
+          local_tools:   tools,
+          mcp_servers:   mcp,
+          config:        run_config
+        )
+        task :verify_b, worker_b, depends_on: :none
+
+        reconciler = RobotLab.build(
+          name:          "reconciler",
+          model:         model_id,
+          system_prompt: "Compare two independent answers to the same question. " \
+                         "Identify agreements and disagreements. " \
+                         "Produce a final, reconciled answer that is most accurate. " \
+                         "Note any areas of uncertainty.",
+          config:        run_config
+        )
+        task :reconcile, reconciler, depends_on: %i[verify_a verify_b]
+      end
+    end
+  end
+end

data/lib/aia.rb

@@ -1,65 +1,100 @@
 # lib/aia.rb
 #
-# This is the main entry point for the AIA application.
-# The AIA module serves as the namespace for the AIA application, which
-# provides an interface for interacting with AI models and managing prompts.
-
-require 'ruby_llm'
-require 'ruby_llm/mcp'
-
-# NOTE: Complex parameters are now supported natively in ruby_llm-mcp >= 0.8.0
-#       The support_complex_parameters! method has been removed.
+# Main entry point for the AIA application (v2).
+# AIA is a thin CLI shell orchestrating robot_lab robots.
 
+gem 'bigdecimal', '>= 4.0'
+require 'bigdecimal'
+require 'robot_lab'
 require 'pm'
 
-
-require 'debug_me'
-include DebugMe
-$DEBUG_ME = false
-DebugMeDefaultOptions[:skip1] = true
-
-require_relative 'extensions/openstruct_merge'    # adds self.merge self.get_value
-require_relative 'extensions/ruby_llm/modalities' # adds model.modalities.text_to_text? etc.
-
-require_relative 'refinements/string' # adds #include_any? #include_all?
+require_relative 'aia/patches/ruby_llm_tool_error'
+require_relative 'aia/patches/ruby_llm_streaming_error'
 
 require_relative 'aia/errors'
+require_relative 'aia/timing'
+require_relative 'aia/tool_introspection'
+require_relative 'aia/turn_state'
+require_relative 'aia/content_extractor'
+require_relative 'aia/speech'
 require_relative 'aia/utility'
+require_relative 'aia/mcp_server_config'
 require_relative 'aia/skill_utils'
 require_relative 'aia/version'
 require_relative 'aia/config'
 require_relative 'aia/logger'
 
-# Top-level logger method available anywhere in the application
-def logger
-  AIA::LoggerManager.aia_logger
-end
-
 require_relative 'aia/config/cli_parser'
 require_relative 'aia/config/validator'
 require_relative 'aia/prompt_handler'
-require_relative 'aia/ruby_llm_adapter'
+require_relative 'aia/tool_loader'
+require_relative 'aia/plugin_loader'
+require_relative 'aia/plugin_monitor'
+require_relative 'aia/spawn_spec_parser'
+require_relative 'aia/crew'
+require_relative 'aia/tools/recruit_robot_tool'
+require_relative 'aia/tools/reskill_robot_tool'
+require_relative 'aia/system_prompt_assembler'
+require_relative 'aia/mcp_config_normalizer'
+require_relative 'aia/network_memory_manager'
+require_relative 'aia/robot_factory'
+require_relative 'aia/robot_builder'
 require_relative 'aia/directive_processor'
-require_relative 'aia/history_manager'
+require_relative 'aia/variable_input_collector'
 require_relative 'aia/ui_presenter'
-require_relative 'aia/chat_processor_service'
 require_relative 'aia/input_collector'
-require_relative 'aia/prompt_pipeline'
+require_relative 'aia/handler_context'
+require_relative 'aia/handler_protocol'
+require_relative 'aia/model_alias_registry'
+require_relative 'aia/model_switch_handler'
+require_relative 'aia/mcp_discovery'
+require_relative 'aia/mcp_grouper'
+require_relative 'aia/cost_calculator'
+require_relative 'aia/session_tracker'
+require_relative 'aia/similarity_scorer'
+require_relative 'aia/fact_asserter'
+require_relative 'aia/tool_filter'
+require_relative 'aia/tool_filter_registry'
+require_relative 'aia/tool_filter_strategy'
+require_relative 'aia/streaming_runner'
+require_relative 'aia/mention_router'
+require_relative 'aia/special_mode_handler'
+require_relative 'aia/mcp_connection_manager'
+require_relative 'aia/startup_coordinator'
+require_relative 'aia/pipeline_orchestrator'
 require_relative 'aia/chat_loop'
 require_relative 'aia/session'
 
 # The AIA module serves as the namespace for the AIA application, which
 # provides an interface for interacting with AI models and managing prompts.
 module AIA
+  require 'debug_me'
+  include DebugMe
+
+  $DEBUG_ME = false
+  DebugMeDefaultOptions[:skip1] = true
+
   at_exit do
-    warn 'Exiting AIA application...'
+    $stderr.puts 'Exiting AIA application...'
   end
 
   @config = nil
   @client = nil
+  @session_tracker = nil
+  @turn_state = TurnState.new
 
   class << self
-    attr_accessor :config, :client
+    attr_accessor :config, :client, :session_tracker, :turn_state, :task_coordinator
+
+    def logger
+      AIA::LoggerManager.aia_logger
+    end
+
+    def reset!
+      @config = @client = @session_tracker = @turn_state =
+                            @task_coordinator = nil
+      ToolLoader.reset_instance!
+    end
 
     def good_file?(filename)
       File.exist?(filename) &&
@@ -67,78 +102,104 @@ module AIA
         !File.directory?(filename)
     end
 
-
     def bad_file?(filename)
       !good_file?(filename)
     end
 
-
     # Convenience flag accessors (delegate to config.flags section)
     def chat?
       @config&.flags&.chat == true
     end
 
-
     def debug?
       @config&.flags&.debug == true
     end
 
+    # Emit a warning always; if --debug is active and an exception is given,
+    # also print the first 5 backtrace frames so errors are diagnosable.
+    #
+    # @param msg [String]
+    # @param exc [Exception, nil]
+    def debug_warn(msg, exc: nil)
+      $stderr.puts msg
+      return unless exc && exc.backtrace && config&.flags&.debug
+      $stderr.puts exc.backtrace.first(5).join("\n")
+    end
 
     def verbose?
       @config&.flags&.verbose == true
     end
 
-
     def fuzzy?
       @config&.flags&.fuzzy == true
     end
 
-
     def speak?
       @config&.flags&.speak == true
     end
 
+    def paint?
+      @config&.flags&.paint == true
+    end
 
     def append?
       @config&.output&.append == true
     end
 
-
+    # :reek:TooManyStatements -- application boot sequence: parse, validate, log, load plugins, build robots, start session
     def run
-      # Parse CLI arguments
       cli_overrides = CLIParser.parse
-
-      # Create config with CLI overrides
       @config = Config.setup(cli_overrides)
+      return if ConfigValidator.tailor(@config) == :early_exit
+
+      log_startup
+
+      PluginLoader.load!(@config)
+      start_plugin_monitor
+      RobotFactory.setup(@config)
+      load_fzf_integration
+      start_session
+    rescue AIA::ConfigurationError => e
+      $stderr.puts e.message
+      exit 1
+    rescue AIA::Error => e
+      $stderr.puts e.message
+      exit 1
+    end
 
-      # Validate and tailor configuration (handles --dump early exit)
-      ConfigValidator.tailor(@config)
-
-      # Load Fzf if fuzzy search is enabled and fzf is installed
-      if @config.flags.fuzzy
-        begin
-          if system('which fzf >/dev/null 2>&1')
-            require_relative 'aia/fzf'
-          else
-            warn 'Warning: Fuzzy search enabled but fzf not found. Install fzf for enhanced search capabilities.'
-          end
-        rescue StandardError => e
-          warn "Warning: Failed to load fzf: #{e.message}"
-        end
-      end
+    private
+
+    # Record startup in all three log files. Only aia.log gets the full
+    # configuration dump; llm.log and mcp.log just note that AIA started,
+    # since their configuration is already covered by the aia.log entry.
+    def log_startup
+      LoggerManager.aia_logger.debug('AIA started up.', @config.to_h)
+      LoggerManager.llm_logger.debug('AIA started up.')
+      LoggerManager.mcp_logger.debug('AIA started up.')
+    end
 
-      prompt_handler = PromptHandler.new
+    def start_plugin_monitor
+      return unless @config.flags.chat
 
-      @client = RubyLLMAdapter.new
+      @plugin_monitor = PluginMonitor.new(@config).start
+      at_exit { @plugin_monitor&.stop }
+    end
+
+    def load_fzf_integration
+      return unless @config.flags.fuzzy
 
-      # There are two kinds of sessions: batch and chat
-      # A chat session is started when the --chat CLI option is used
-      # BUT its also possible to start a chat session with an initial prompt AND
-      # within that initial prompt there can be a workflow (aka pipeline)
-      # defined.  If that is the case, then the chat session will not start
-      # until the initial prompt has completed its workflow.
+      if system('which fzf >/dev/null 2>&1')
+        require_relative 'aia/fzf'
+      else
+        $stderr.puts 'Warning: Fuzzy search enabled but fzf not found. Install fzf for enhanced search capabilities.'
+      end
+    rescue StandardError => e
+      $stderr.puts "Warning: Failed to load fzf: #{e.message}"
+    end
 
-      session = Session.new(prompt_handler)
+    def start_session
+      session = Session.new(PromptHandler.new)
+      at_exit { session.cleanup }
       session.start
     end
   end

data/mkdocs.yml

@@ -151,6 +151,7 @@ nav:
     - Getting Started: guides/getting-started.md
     - Chat Mode: guides/chat.md
     - Working with Models: guides/models.md
+    - Crews: guides/crew.md
     - Local Models: guides/local-models.md
     - Available Models: guides/available-models.md
     - Image Generation: guides/image-generation.md