aia 1.1.1 → 2.0.0.0.pre.beta2

data/lib/aia/robot_factory.rb

@@ -0,0 +1,338 @@
+# frozen_string_literal: true
+
+# lib/aia/robot_factory.rb
+#
+# The core new abstraction in AIA v2.
+# Builds RobotLab::Robot or RobotLab::Network instances from AIA configuration.
+# Replaces the entire lib/aia/adapter/ directory from v1.
+
+require 'pm'
+require_relative 'robot_namer'
+require_relative 'tool_loader'
+require_relative 'system_prompt_assembler'
+require_relative 'network_builder'
+require_relative 'history_transfer'
+
+module AIA
+  # :reek:TooManyMethods -- factory facade: every robot/network build variant plus its run-config helpers lives behind one entry point
+  class RobotFactory
+    # The max_tokens default from defaults.yml — optimised for cloud APIs that treat
+    # it as an output-only cap. Local providers (Ollama, LM Studio) bound input+output
+    # to a shared context window, so sending this value causes truncation on long turns.
+    DEFAULT_LOCAL_MAX_TOKENS = 32_767
+
+    class << self
+      # One-time startup configuration of RobotLab loggers and providers.
+      # Must be called once before the first build (e.g., in AIA.run).
+      #
+      # @param config [AIA::Config] the AIA configuration
+      def setup(config)
+        configure_robot_lab(config)
+      end
+
+      # Build a Robot or Network from the current AIA config
+      #
+      # @param config [AIA::Config] the AIA configuration
+      # @return [RobotLab::Robot, RobotLab::Network] the built robot or network
+      def build(config = AIA.config)
+        namer = RobotNamer.new(first_name: 'Tobor')
+        apply_tool_cache(config)
+
+        # The interactive session always runs a *crew* (a Network), so robots can
+        # be recruited/dropped at runtime. A single model is wrapped in a one-member
+        # crew whose chief is that robot; multi-model aggregation networks are
+        # already Networks. (Normal turns still stream via the chief — see ChatLoop.)
+        if config.models.length > 1
+          build_multi_model(config, namer)
+        else
+          build_crew(build_single_robot(config, namer))
+        end
+      rescue RubyLLM::ModelNotFoundError => e
+        model_names = config.models.map(&:name).join(', ')
+        raise AIA::ConfigurationError,
+              "#{e.message}\nRequested model(s): #{model_names}\nRun 'aia --available-models' to see available models."
+      end
+
+      # Rebuild robot(s) after config changes (e.g., /model, /config directives).
+      # Supports conversation history transfer modes.
+      # Reuses cached tools from the initial build (I4/I5).
+      #
+      # @param config [AIA::Config] the AIA configuration
+      # @param history_mode [Symbol] :clean, :replay, or :summarize
+      # @return [RobotLab::Robot, RobotLab::Network]
+      def rebuild(config = AIA.config, history_mode: :clean)
+        old_robot = AIA.client
+        new_robot = build(config)
+
+        case history_mode
+        when :replay
+          HistoryTransfer.replay_history(old_robot, new_robot)
+        when :summarize
+          HistoryTransfer.summarize_history(old_robot, new_robot)
+        end
+
+        new_robot
+      end
+
+      # --- Forwarding wrappers for backward compatibility ---
+
+      def clear_tool_cache!
+        ToolLoader.clear_cache!
+      end
+
+      def filtered_tools(config)
+        ToolLoader.filtered_tools(config)
+      end
+
+      def resolve_system_prompt(config, model_spec = nil)
+        SystemPromptAssembler.resolve_system_prompt(config, model_spec)
+      end
+
+      def build_identity_prompt(robot_name, spec, roster)
+        SystemPromptAssembler.build_identity_prompt(robot_name, spec, roster)
+      end
+
+      # Build a concurrent MCP network where independent server groups
+      # run in parallel with a synthesizer to merge results.
+      #
+      # @param config [AIA::Config] the AIA configuration
+      # @param server_groups [Array<Array<Hash>>] groups of MCP server configs
+      # @return [RobotLab::Network]
+      def build_concurrent_mcp_network(config, server_groups)
+        namer = RobotNamer.new(first_name: 'Tobor')
+        NetworkBuilder.build_concurrent_mcp_network(config, namer, server_groups)
+      end
+
+      # Build a single robot for one model.
+      # Delegates to RobotBuilder for single-robot construction.
+      #
+      # @param config [AIA::Config] the AIA configuration
+      # @param namer [AIA::RobotNamer] fresh namer for this build
+      # @return [RobotLab::Robot]
+      def build_single_robot(config, namer)
+        RobotBuilder.build(config, namer: namer)
+      end
+
+      # Reuse the build-time tool cache when present, else load tools fresh.
+      def apply_tool_cache(config)
+        cached = ToolLoader.cached_tools
+        if cached
+          config.loaded_tools = cached
+          config.tool_names = cached.map { |t| t.respond_to?(:name) ? t.name : t.class.name }.join(', ')
+        else
+          ToolLoader.load_tools(config)
+        end
+      end
+
+      # Wrap a single robot in a one-member crew Network so the session can
+      # recruit/drop robots at runtime. The robot becomes the crew's chief
+      # (the lone pipeline task); normal turns are routed to it directly so
+      # token streaming is preserved.
+      #
+      # @param chief [RobotLab::Robot]
+      # @return [RobotLab::Network]
+      def build_crew(chief)
+        RobotLab.create_network(name: 'aia-crew') do
+          task chief.name.to_sym, chief, depends_on: :none
+        end
+      end
+
+      # Build RunConfig from AIA configuration.
+      # Uses the ruby_llm model registry to skip parameters the model doesn't support:
+      # - temperature is omitted for models that declare temperature: false in metadata
+      # - max_tokens remains a RobotLab::RunConfig field; AIA normalizes it at
+      #   the RubyLLM/OpenAI provider boundary for models that need
+      #   max_completion_tokens
+      # :reek:TooManyStatements -- one guarded param per LLM tuning knob, with provider-specific max_tokens handling
+      def build_run_config(config)
+        model_spec = config.models.first
+        llm        = config.llm
+        params     = {}
+
+        temp = llm.temperature
+        params[:temperature] = temp if temp && model_supports_temperature?(model_spec)
+
+        max = llm.max_tokens
+        # Local providers (Ollama, LM Studio) have a small total context window
+        # (input + output combined, typically 32768 tokens for qwen3-class models).
+        # Sending the cloud default of 32767 as num_predict leaves almost no room
+        # once the input context grows across turns, causing mid-response truncation.
+        # Skip max_tokens for local providers when it's still at the cloud default;
+        # honour it when the user has explicitly set a smaller value.
+        local = model_spec&.local_provider?
+        params[:max_tokens] = max if max && !(local && max == DEFAULT_LOCAL_MAX_TOKENS)
+
+        tp = llm.top_p
+        params[:top_p] = tp if tp
+
+        fp = llm.frequency_penalty
+        params[:frequency_penalty] = fp if fp && fp != 0.0
+
+        pp = llm.presence_penalty
+        params[:presence_penalty] = pp if pp && pp != 0.0
+
+        RobotLab::RunConfig.new(**params)
+      end
+
+      # Returns false for models that explicitly declare temperature: false in the
+      # ruby_llm model registry (e.g. gpt-5.4, o1, o3 reasoning models).
+      def model_supports_temperature?(model_spec)
+        return true unless model_spec
+        info = RubyLLM.models.find(model_spec.name)
+        info.metadata[:temperature] != false
+      rescue StandardError
+        true
+      end
+
+      # Normalize all configured MCP server configs for robot_lab.
+      # Filtering/selection is MCPDiscovery's responsibility — this just normalizes shape.
+      def mcp_server_configs(config)
+        return [] if config.flags.no_mcp
+        Array(config.mcp_servers).map { |s| MCPConfigNormalizer.normalize(s) }
+      end
+
+      # Normalize a single MCP server config to robot_lab's nested transport format.
+      # Delegates to MCPConfigNormalizer.
+      def normalize_mcp_config(server)
+        MCPConfigNormalizer.normalize(server)
+      end
+
+      # Initialize shared memory for a network with session context.
+      # Delegates to NetworkMemoryManager.
+      #
+      # @param network [RobotLab::Network]
+      # @param config [AIA::Config]
+      # @return [RobotLab::Network]
+      def initialize_network_memory(network, config)
+        NetworkMemoryManager.initialize_memory(network, config)
+      end
+
+      # Set up memory subscriptions for debug logging and completion tracking.
+      # Delegates to NetworkMemoryManager.
+      #
+      # @param network [RobotLab::Network]
+      # @param config [AIA::Config]
+      def setup_memory_subscriptions(network, config)
+        NetworkMemoryManager.setup_subscriptions(network, config)
+      end
+
+      # Attach a shared TypedBus message bus to all robots in a network.
+      #
+      # @param network [RobotLab::Network]
+      # @return [TypedBus::MessageBus, nil]
+      def attach_bus(network)
+        return nil unless network.respond_to?(:robots)
+
+        bus = TypedBus::MessageBus.new
+        network.robots.each_value { |robot| robot.with_bus(bus) }
+        bus
+      end
+
+      # Build a RobotLab::Robot for a model spec, applying provider resolution.
+      # Centralizes the "set provider if the spec has one, then build" tail that
+      # every robot/network builder needs, so local-provider routing (ollama/lms)
+      # can't be forgotten at a new build site.
+      #
+      # @param spec [AIA::Config::ModelSpec] the model spec (supplies model: and provider)
+      # @param opts [Hash] forwarded to RobotLab.build (name:, system_prompt:,
+      #   local_tools:, mcp_servers:, config:, on_content:, ...). Do NOT pass model:.
+      # @return [RobotLab::Robot]
+      def build_robot(spec, **opts)
+        opts[:provider] = resolve_provider(spec) if spec.provider
+        RobotLab.build(model: spec.name, **opts)
+      end
+
+      # Map AIA provider aliases to RubyLLM provider slugs.
+      def resolve_provider(model_spec)
+        case model_spec.provider
+        when 'lms' then 'openai'
+        else model_spec.provider
+        end
+      end
+
+      private
+
+      # Configure RobotLab providers from AIA config
+      def configure_robot_lab(config)
+        # Configure loggers before any API calls
+        AIA::LoggerManager.configure_llm_logger
+        AIA::LoggerManager.configure_mcp_logger
+
+        # Route RobotLab's internal logging through AIA's MCP logger
+        # so entries go to the configured log files instead of STDOUT.
+        # Must use direct assignment — block form doesn't set runtime attrs.
+        RobotLab.config.logger = AIA::LoggerManager.mcp_logger
+
+        RobotLab.config do |c|
+          c.ruby_llm do |r|
+            r.request_timeout = 120
+          end
+        end
+
+        # RobotLab's after_load sets PM.config.prompts_dir to its own default ('prompts').
+        # Restore AIA's configured prompts dir so PM.parse finds the correct files.
+        PM.configure { |c| c.prompts_dir = AIA.config.prompts.dir }
+
+        # Configure local provider API endpoints from environment variables
+        configure_local_providers(config)
+
+        # Wire audio model settings into RubyLLM config
+        configure_audio(config)
+      end
+
+      # Wire AIA's audio config into RubyLLM so transcription calls pick up
+      # the user-configured model without requiring explicit model: arguments.
+      # speech_model has no ruby_llm TTS API backing yet — it is exposed as
+      # the SPEECH_MODEL env var for custom speak_command scripts.
+      def configure_audio(config)
+        transcription_model = config.audio&.transcription_model
+        return unless transcription_model
+
+        RubyLLM.configure { |c| c.default_transcription_model = transcription_model }
+      end
+
+      # Set API base URLs for local providers (Ollama, LM Studio) so
+      # RubyLLM can reach them. Reads from standard env vars.
+      def configure_local_providers(config)
+        providers_used = config.models.map(&:provider).compact.uniq
+
+        RubyLLM.configure do |c|
+          # Always configure Ollama's base so switching to an `ollama/` model
+          # mid-session works even when the session started on a cloud model.
+          # It only affects the Ollama provider, so it's harmless when unused.
+          # RubyLLM's Ollama provider subclasses OpenAI and appends
+          # `chat/completions`, so the base must include the `/v1` suffix.
+          c.ollama_api_base = ENV.fetch('OLLAMA_API_BASE', 'http://localhost:11434/v1')
+
+          # LM Studio exposes an OpenAI-compatible API and reuses the OpenAI
+          # provider, so only override the OpenAI base when an `lms/` model is
+          # actually in use — otherwise it would hijack real OpenAI requests.
+          # The OpenAI provider POSTs the relative `chat/completions`, so (like
+          # the real `https://api.openai.com/v1` default and the Ollama base) the
+          # LM Studio base must include the `/v1` suffix — otherwise requests hit
+          # `:1234/chat/completions`, LM Studio 404s, and ruby_llm's streaming
+          # error handler masks it as `delete_prefix for nil`.
+          if providers_used.include?('lms')
+            c.openai_api_base = ENV.fetch('LMS_API_BASE', 'http://localhost:1234/v1')
+          end
+        end
+      end
+
+      # Decide between consensus and parallel multi-model.
+      # Initializes shared memory and subscriptions on the resulting network.
+      #
+      # @param config [AIA::Config] the AIA configuration
+      # @param namer [AIA::RobotNamer] fresh namer for this build
+      def build_multi_model(config, namer)
+        network = if config.flags.consensus
+                    NetworkBuilder.build_consensus_network(config, namer)
+                  else
+                    NetworkBuilder.build_parallel_network(config, namer)
+                  end
+        initialize_network_memory(network, config)
+        setup_memory_subscriptions(network, config)
+        network
+      end
+    end
+  end
+end

data/lib/aia/robot_namer.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+# lib/aia/robot_namer.rb
+#
+# Generates memorable one-word names for robots based on their model.
+# Used instead of technical names like "aia-claude-sonnet-4".
+
+module AIA
+  class RobotNamer
+    # Curated names for known model patterns (matched in order, first wins)
+    MODEL_NAMES = [
+      # Claude family
+      [/claude.*opus.*4/i,      'Virtuoso'],
+      [/claude.*opus/i,         'Maestro'],
+      [/claude.*sonnet.*4/i,    'Lyric'],
+      [/claude.*sonnet.*3\.5/i, 'Muse'],
+      [/claude.*sonnet/i,       'Poet'],
+      [/claude.*haiku/i,        'Zen'],
+
+      # GPT family
+      [/gpt-4\.1/i,             'Vanguard'],
+      [/gpt-4o-mini/i,          'Spark'],
+      [/gpt-4o/i,               'Flash'],
+      [/gpt-4-turbo/i,          'Bolt'],
+      [/gpt-4/i,                'Titan'],
+      [/gpt-3.*turbo/i,         'Dash'],
+      [/gpt-5-nano/i,           'Mote'],
+      [/gpt-5-mini/i,           'Flare'],
+      [/gpt-5/i,                'Apex'],
+      [/o1-mini/i,              'Ponder'],
+      [/o1-pro/i,               'Scholar'],
+      [/o1\b/i,                 'Thinker'],
+      [/o3-mini/i,              'Deduce'],
+      [/o3\b/i,                 'Reason'],
+      [/o4-mini/i,              'Nimble'],
+
+      # Google
+      [/gemini.*flash/i,        'Prism'],
+      [/gemini.*pro/i,          'Atlas'],
+      [/gemini/i,               'Twin'],
+
+      # Open source / local
+      [/llama/i,                'Sherpa'],
+      [/mistral.*large/i,       'Cyclone'],
+      [/mistral/i,              'Gale'],
+      [/mixtral/i,              'Tempest'],
+      [/phi/i,                  'Quark'],
+      [/qwen/i,                 'Jade'],
+      [/deepseek.*coder/i,      'Cipher'],
+      [/deepseek/i,             'Diver'],
+      [/codestral/i,            'Rune'],
+      [/command.*r\+/i,         'Admiral'],
+      [/command/i,              'Captain'],
+      [/falcon/i,               'Talon'],
+      [/vicuna/i,               'Voyager'],
+      [/yi\b/i,                 'Sage'],
+      [/starcoder/i,            'Nova'],
+      [/granite/i,              'Monolith'],
+      [/solar/i,                'Corona'],
+      [/orca/i,                 'Tide'],
+      [/wizard/i,               'Merlin'],
+      [/dolphin/i,              'Reef'],
+      [/nous/i,                 'Oracle'],
+      [/stable/i,               'Anchor'],
+      [/gemma/i,                'Jewel']
+    ].freeze
+
+    # Fallback pool for unrecognized models — deterministically
+    # selected by hashing the model name
+    FALLBACK_NAMES = %w[
+      Beacon Drift Echo Fable Glimmer Halo Iris
+      Kindle Lumen Mirth Nexus Orbit Pixel Quill
+      Ripple Sentry Trace Unity Vault Wisp Zephyr
+      Ember Frost Crest Flint Haze Slate Plume
+      Comet Aura Blaze Dusk Flux Helix Onyx
+    ].freeze
+
+    def initialize(first_name: nil)
+      @first_name = first_name
+      @used_names = {}
+    end
+
+    def name_for(model_name)
+      if @used_names.empty? && @first_name
+        return unique_name(@first_name)
+      end
+
+      model_name = model_name.to_s
+      base = find_base_name(model_name)
+      unique_name(base)
+    end
+
+    private
+
+    def find_base_name(model_name)
+      MODEL_NAMES.each do |pattern, name|
+        return name if model_name.match?(pattern)
+      end
+
+      # Deterministic fallback based on model name
+      index = model_name.bytes.sum % FALLBACK_NAMES.size
+      FALLBACK_NAMES[index]
+    end
+
+    def unique_name(base)
+      count = @used_names[base] = (@used_names[base] || 0) + 1
+      count == 1 ? base : "#{base}#{count}"
+    end
+  end
+end

data/lib/aia/session.rb

@@ -1,7 +1,11 @@
-# lib/aia/session.rb
 # frozen_string_literal: true
 
-require "tty-spinner"
+# lib/aia/session.rb
+#
+# Simplified orchestrator for AIA v2.
+# Builds robot via RobotFactory, processes pipeline, enters chat.
+# Integrates TrakFlow for pipeline tracking and session continuity.
+
 require "tty-screen"
 require "reline"
 require "pm"
@@ -9,17 +13,20 @@ require "json"
 require "fileutils"
 require "amazing_print"
 require_relative "directive_processor"
-require_relative "history_manager"
+require_relative "variable_input_collector"
 require_relative "ui_presenter"
-require_relative "chat_processor_service"
 require_relative "prompt_handler"
 require_relative "utility"
 require_relative "input_collector"
-require_relative "prompt_pipeline"
+require_relative "robot_factory"
+require_relative "tool_filter_registry"
 require_relative "chat_loop"
 
 module AIA
+  # :reek:TooManyInstanceVariables -- session hub wires presenter, trackers, handlers, and robot; each collaborator is a named field
   class Session
+    include ContentExtractor
+
     def initialize(prompt_handler)
       @prompt_handler = prompt_handler
 
@@ -29,7 +36,23 @@ module AIA
 
     # Starts the session, processing all prompts in the pipeline and then
     # optionally starting an interactive chat session.
+    # :reek:TooManyStatements -- session boot script: build robot, startup coordination, optional immediate chat, pipeline run, chat handoff
     def start
+      cfg = AIA.config
+
+      # Build robot or network
+      @robot = RobotFactory.build(cfg)
+      AIA.client = @robot
+
+      # Run all startup coordination: MCP, tools, filters, task board, bus
+      coordinator = StartupCoordinator.new(robot: @robot, ui_presenter: @ui_presenter)
+      coordinator.run(cfg)
+      @filters     = coordinator.filters
+      @mcp_manager = coordinator.mcp_manager
+
+      # Store session tracker globally for KBS access
+      AIA.session_tracker = @session_tracker
+
       # Handle special chat-only cases first
       if should_start_chat_immediately?
         AIA::Utility.robot
@@ -38,38 +61,85 @@ module AIA
       end
 
       # Process all prompts in the pipeline
-      @prompt_pipeline.process_all
+      PipelineOrchestrator.new(
+        robot:           @robot,
+        prompt_handler:  @prompt_handler,
+        input_collector: @input_collector,
+        ui_presenter:    @ui_presenter,
+        session_tracker: @session_tracker
+      ).process(cfg)
 
       # Start chat mode after all prompts are processed
-      if AIA.chat?
-        AIA::Utility.robot
-        @ui_presenter.display_separator
-        @chat_loop.start(skip_context_files: true)
-      end
+      return unless AIA.chat?
+      @chat_loop = build_chat_loop
+      AIA::Utility.robot
+      @ui_presenter.display_separator
+      @chat_loop.start(skip_context_files: true)
+    end
+
+    # Release all held resources: MCP connections and filter state.
+    # Called automatically via at_exit registered in #start.
+    # Safe to call multiple times.
+    def cleanup
+      @mcp_manager&.close_all
+      @filters&.each_value(&:cleanup)
     end
 
+    MAX_HISTORY_BYTES = 10 * 1024 * 1024  # 10 MB
+
     private
 
     def initialize_components
       @ui_presenter        = UIPresenter.new
       @directive_processor = DirectiveProcessor.new
-      @chat_processor      = ChatProcessorService.new(@ui_presenter, @directive_processor)
       @input_collector     = InputCollector.new
-      @prompt_pipeline     = PromptPipeline.new(@prompt_handler, @chat_processor, @ui_presenter, @input_collector)
-      @chat_loop           = ChatLoop.new(@chat_processor, @ui_presenter, @directive_processor)
+
+      @session_tracker     = SessionTracker.new
+      @alias_registry      = ModelAliasRegistry.new(
+        AIA.config.respond_to?(:model_aliases) ? (AIA.config.model_aliases || {}) : {}
+      )
+      @chat_loop           = nil  # created after robot is built
+
+      rotate_history_log_if_needed
+    end
+
+    # Rotate the prompt history log if it has grown too large.
+    # Renames <file> to <file>.1 so the next session starts fresh.
+    # Called once at session initialization.
+    def rotate_history_log_if_needed
+      history_file = AIA.config.output.history_file
+      return unless history_file && File.exist?(history_file)
+      return unless File.size(history_file) > MAX_HISTORY_BYTES
+
+      archive = "#{history_file}.1"
+      FileUtils.mv(history_file, archive)
+      $stderr.puts "History log rotated: #{File.basename(history_file)} → #{File.basename(archive)}"
+    rescue StandardError => e
+      $stderr.puts "Warning: Could not rotate history log: #{e.message}"
     end
 
     def setup_output_file
       out_file = AIA.config.output.file
-      if out_file && !out_file.nil? && !AIA.append? && File.exist?(out_file)
-        File.open(out_file, "w") { } # Truncate the file
-      end
+      return unless out_file && !out_file.nil? && !AIA.append? && File.exist?(out_file)
+      File.write(out_file, '')
+    end
+
+    def build_chat_loop
+      ChatLoop.new(
+        @robot, @ui_presenter, @directive_processor,
+        session_tracker: @session_tracker,
+        alias_registry: @alias_registry,
+        filters: @filters
+      )
     end
 
     # Check if we should start chat immediately without processing any prompts
     def should_start_chat_immediately?
       return false unless AIA.chat?
 
+      # Create chat loop now that robot is available
+      @chat_loop = build_chat_loop
+
       AIA.config.pipeline.empty? || AIA.config.pipeline.all? { |id| id.nil? || id.empty? }
     end
   end