aia 1.1.1 → 2.0.0.0.pre.alpha

data/lib/aia/prompt_decomposer.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+# lib/aia/prompt_decomposer.rb
+#
+# Decomposes complex prompts into independent sub-tasks.
+# A coordinator robot breaks them down, specialist robots execute,
+# and the coordinator reassembles.
+
+require 'json'
+
+module AIA
+  class PromptDecomposer
+    include ContentExtractor
+
+    DECOMPOSITION_PROMPT = <<~PROMPT
+      Analyze this user request and determine if it can be broken into independent sub-tasks.
+
+      Rules:
+      - Only decompose if sub-tasks are truly independent (can run in parallel)
+      - Each sub-task should be self-contained
+      - 2-5 sub-tasks maximum
+      - Keep sub-task descriptions clear and specific
+      - Use an empty subtasks array if the request cannot be meaningfully decomposed
+
+      User request: %{prompt}
+    PROMPT
+
+    # Appended to DECOMPOSITION_PROMPT when the model does not support
+    # structured output and with_schema cannot be used.
+    FALLBACK_JSON_INSTRUCTION = <<~INSTRUCTION
+
+      Respond with ONLY a JSON object — no explanation, no markdown, no prose:
+      {"subtasks": ["sub-task description 1", "sub-task description 2"]}
+    INSTRUCTION
+
+    # JSON schema for structured-output-capable models.
+    # Uses a wrapper object because Claude requires a top-level object.
+    SUBTASKS_SCHEMA = {
+      name: 'subtask_decomposition',
+      schema: {
+        type: 'object',
+        properties: {
+          subtasks: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Independent sub-task descriptions. Empty array if not decomposable.'
+          }
+        },
+        required: ['subtasks'],
+        additionalProperties: false
+      },
+      strict: true
+    }.freeze
+
+    SYNTHESIS_TEMPLATE = <<~PROMPT
+      Original request: %{prompt}
+
+      Sub-task results:
+      %{results}
+
+      Synthesize these results into a coherent final response that fully addresses the original request.
+    PROMPT
+
+    def initialize(robot)
+      @robot = robot
+    end
+
+    # Attempt to decompose a prompt into sub-tasks.
+    #
+    # Uses a temporary probe robot so the decomposition prompt and response do
+    # not pollute the main conversation history. When the configured model
+    # supports structured output (structured_output? == true) with_schema is
+    # used to get a guaranteed Hash back. Otherwise a JSON instruction is
+    # appended to the prompt and the text response is parsed manually.
+    #
+    # @param prompt [String] the user's prompt
+    # @return [Array<String>] sub-task descriptions (empty if not decomposable)
+    def decompose(prompt)
+      probe      = build_probe_robot
+      use_schema = structured_output?
+
+      if use_schema
+        probe.with_schema(SUBTASKS_SCHEMA)
+        full_prompt = DECOMPOSITION_PROMPT % { prompt: prompt }
+      else
+        AIA.logger.warn("PromptDecomposer: configured model does not support structured output — using JSON prompt fallback")
+        full_prompt = (DECOMPOSITION_PROMPT + FALLBACK_JSON_INSTRUCTION) % { prompt: prompt }
+      end
+
+      result   = probe.run(full_prompt, mcp: :none, tools: :none)
+      content  = extract_content(result)
+      AIA.logger.debug("PromptDecomposer#decompose content class=#{content.class}")
+      subtasks = extract_subtasks(content)
+      subtasks.is_a?(Array) ? subtasks.select { |t| t.is_a?(String) && !t.empty? } : []
+    rescue StandardError => e
+      AIA.logger.warn("PromptDecomposer#decompose failed: #{e.class}: #{e.message}")
+      []
+    end
+
+    # Synthesize sub-task results into a final response.
+    #
+    # @param prompt [String] the original user prompt
+    # @param results [Array<String>] results from each sub-task
+    # @return the synthesized response
+    def synthesize(prompt, results)
+      formatted_results = results.each_with_index.map do |r, i|
+        "Sub-task #{i + 1}:\n#{r}"
+      end.join("\n\n")
+
+      @robot.run(
+        SYNTHESIS_TEMPLATE % { prompt: prompt, results: formatted_results },
+        mcp: :none, tools: :none
+      )
+    end
+
+    private
+
+    def structured_output?
+      RubyLLM.models.find(AIA.config.models.first.internal_id).structured_output?
+    rescue StandardError
+      false
+    end
+
+    # Build a fresh temporary robot for the decomposition probe.
+    # This robot has no conversation history and is discarded after use,
+    # keeping @robot's history clean for the normal or synthesis path.
+    def build_probe_robot
+      config     = AIA.config
+      run_config = RobotFactory.build_run_config(config)
+      RobotLab.build(
+        name:          "decompose-probe",
+        model:         config.models.first.internal_id,
+        system_prompt: nil,
+        config:        run_config
+      )
+    end
+
+    # Extract the subtasks array from the probe response.
+    # Hash path: with_schema caused ruby_llm to auto-parse the JSON response.
+    # String path: fallback text parsing for models without structured output.
+    def extract_subtasks(content)
+      case content
+      when Hash
+        content['subtasks'] || content[:subtasks] || []
+      when Array
+        content
+      when String
+        parsed = JSON.parse(content.gsub(/```(?:json)?\s*/i, '').gsub('```', '').strip)
+        parsed.is_a?(Hash) ? parsed['subtasks'] || parsed[:subtasks] || [] : parsed
+      else
+        []
+      end
+    rescue JSON::ParserError
+      []
+    end
+  end
+end

data/lib/aia/prompt_handler.rb

@@ -3,15 +3,14 @@
 require 'pm'
 require 'erb'
 
-
 module AIA
   class PromptHandler
     include AIA::SkillUtils
 
     # Struct for path-based role content (bypasses PM parsing)
     RoleContent = Struct.new(:content) do
-      def to_s; content; end
-      def metadata; nil; end
+      def to_s = content
+      def metadata = nil
     end
 
     # Root-level YAML keys that are shorthands for deeper config paths
@@ -25,7 +24,7 @@ module AIA
       'next'        => [%w[config next], %w[config pipeline]],
       'pipeline'    => [%w[config pipeline], %w[config next]],
       'shell'       => [%w[config shell], %w[config flags shell]],
-      'erb'         => [%w[config erb], %w[config flags erb]],
+      'erb'         => [%w[config erb], %w[config flags erb]]
     }.freeze
 
     def initialize
@@ -39,7 +38,6 @@ module AIA
       register_pm_directives
     end
 
-
     def fetch_prompt(prompt_id)
       if prompt_id == '__FUZZY_SEARCH__'
         return fuzzy_search_prompt('')
@@ -54,7 +52,7 @@ module AIA
       parsed = if File.exist?(prompt_file_path)
                  PM.parse(prompt_id)
                else
-                 warn "Warning: Invalid prompt ID or file not found: #{prompt_id}"
+                 $stderr.puts "Warning: Invalid prompt ID or file not found: #{prompt_id}"
                  logger.warn("Invalid prompt ID or file not found: #{prompt_id}")
                  handle_missing_prompt(prompt_id)
                end
@@ -63,7 +61,6 @@ module AIA
       parsed
     end
 
-
     def fetch_role(role_id)
       return handle_missing_role("roles/") if role_id.nil?
       return fetch_role_from_path(role_id) if path_based_id?(role_id)
@@ -79,7 +76,7 @@ module AIA
                  # and returns the ID string as content.  Parse from raw file content instead.
                  PM.parse_string(File.read(role_file_path))
                else
-                 warn "Warning: Invalid role ID or file not found: #{role_id}"
+                 $stderr.puts "Warning: Invalid role ID or file not found: #{role_id}"
                  logger.warn("Invalid role ID or file not found: #{role_id}")
                  handle_missing_role(role_id)
                end
@@ -88,7 +85,6 @@ module AIA
       parsed
     end
 
-
     # Load role for a specific model (ADR-005)
     # Takes a model spec hash and default role, returns rendered role text
     def load_role_for_model(model_spec, default_role = nil)
@@ -103,12 +99,11 @@ module AIA
       role_parsed = fetch_role(role_id)
       role_parsed.to_s
     rescue => e
-      warn "Warning: Could not load role '#{role_id}' for model: #{e.message}"
+      $stderr.puts "Warning: Could not load role '#{role_id}' for model: #{e.message}"
       logger.warn("Could not load role '#{role_id}' for model: #{e.message}")
       nil
     end
 
-
     # Applies YAML front matter metadata to AIA.config.
     # Processes root-level shorthand keys, detects conflicts with config: section,
     # and deep merges the config: section into AIA.config.
@@ -132,10 +127,8 @@ module AIA
       deep_merge_config(config_section) if config_section
     end
 
-
     private
 
-
     def fetch_executable_prompt
       content = AIA.config.executable_prompt_content
       parsed = PM.parse(content)
@@ -143,18 +136,16 @@ module AIA
       parsed
     end
 
-
     def register_pm_directives
       AIA::Directive.register_all
     end
 
-
     # Detect conflicts between root shorthand keys and the config: section.
     # Raises AIA::ConfigurationError when the same setting is specified in both places.
     def detect_shorthand_conflicts(meta_hash, config_section)
       # Check for mutually exclusive root keys: next and pipeline
-      has_next     = meta_hash.key?('next')     || meta_hash.key?(:next)
-      has_pipeline = meta_hash.key?('pipeline')  || meta_hash.key?(:pipeline)
+      has_next     = meta_hash.key?('next') || meta_hash.key?(:next)
+      has_pipeline = meta_hash.key?('pipeline') || meta_hash.key?(:pipeline)
 
       if has_next && has_pipeline
         raise ConfigurationError, "Both 'next' and 'pipeline' specified at root level — they are mutually exclusive"
@@ -173,14 +164,14 @@ module AIA
 
           unless value.nil?
             raise ConfigurationError,
-              "Conflict: '#{root_key}' at root level and '#{path.join('.')}' in config section"
+                  "Conflict: '#{root_key}' at root level and '#{path.join('.')}' in config section"
           end
         end
       end
     end
 
-
     # Apply root-level shorthand keys to AIA.config
+    # rubocop:disable Metrics/AbcSize
     def apply_root_shorthands(meta_hash)
       # model → AIA.config.models (replace with single-model array)
       model_val = meta_hash['model'] || meta_hash[:model]
@@ -226,11 +217,10 @@ module AIA
 
       # erb → AIA.config.flags.erb (and PM's erb via metadata)
       erb_val = meta_hash['erb'] || meta_hash[:erb]
-      unless erb_val.nil?
-        AIA.config.flags.erb = erb_val
-      end
+      return if erb_val.nil?
+      AIA.config.flags.erb = erb_val
     end
-
+    # rubocop:enable Metrics/AbcSize
 
     def logger
       @logger ||= LoggerManager.aia_logger
@@ -253,7 +243,6 @@ module AIA
       end
     end
 
-
     # Recursively merge a hash into a config object
     def deep_merge_into_config(config_obj, hash)
       hash.each do |key, value|
@@ -266,7 +255,6 @@ module AIA
       end
     end
 
-
     # Dig into a hash with an array of keys, returning nil if any key is missing
     def dig_hash(hash, keys)
       keys.reduce(hash) do |h, key|
@@ -275,7 +263,6 @@ module AIA
       end
     end
 
-
     # Recursively symbolize all keys in a hash
     def symbolize_keys_deep(obj)
       case obj
@@ -290,23 +277,21 @@ module AIA
       end
     end
 
-
     def handle_missing_prompt(prompt_id)
       prompt_id = prompt_id.to_s.strip
       if prompt_id.empty?
-        warn "Error: Prompt ID cannot be empty"
+        $stderr.puts "Error: Prompt ID cannot be empty"
         exit 1
       end
 
       if AIA.config.flags.fuzzy
         fuzzy_search_prompt(prompt_id)
       else
-        warn "Error: Could not find prompt with ID: #{prompt_id}"
+        $stderr.puts "Error: Could not find prompt with ID: #{prompt_id}"
         exit 1
       end
     end
 
-
     def fetch_role_from_path(role_id)
       expanded = File.expand_path(role_id)
       expanded += '.md' if File.extname(expanded).empty?
@@ -320,7 +305,6 @@ module AIA
       RoleContent.new(File.read(expanded))
     end
 
-
     def fuzzy_search_prompt(prompt_id)
       new_prompt_id = search_prompt_id_with_fzf(prompt_id)
 
@@ -331,23 +315,21 @@ module AIA
       PM.parse(new_prompt_id)
     end
 
-
     def handle_missing_role(role_id)
       role_id = role_id.to_s.strip
       if role_id.empty? || role_id == "roles/"
-        warn "Error: Role ID cannot be empty"
+        $stderr.puts "Error: Role ID cannot be empty"
         exit 1
       end
 
       if AIA.config.flags.fuzzy
         fuzzy_search_role(role_id)
       else
-        warn "Error: Could not find role with ID: #{role_id}"
+        $stderr.puts "Error: Could not find role with ID: #{role_id}"
         exit 1
       end
     end
 
-
     def fuzzy_search_role(role_id)
       new_role_id = search_role_id_with_fzf(role_id)
       if new_role_id.nil? || new_role_id.empty?
@@ -357,10 +339,9 @@ module AIA
       PM.parse(new_role_id)
     end
 
-
     def search_prompt_id_with_fzf(initial_query)
       prompt_files = Dir.glob(File.join(@prompts_dir, "*#{AIA.config.prompts.extname}"))
-                       .map { |file| File.basename(file, AIA.config.prompts.extname) }
+                        .map { |file| File.basename(file, AIA.config.prompts.extname) }
       fzf = AIA::Fzf.new(
         list: prompt_files,
         directory: @prompts_dir,
@@ -371,10 +352,9 @@ module AIA
       fzf.run || (raise "No prompt ID selected")
     end
 
-
     def search_role_id_with_fzf(initial_query)
       role_files = Dir.glob(File.join(@roles_dir, "*#{AIA.config.prompts.extname}"))
-                    .map { |file| File.basename(file, AIA.config.prompts.extname) }
+                      .map { |file| File.basename(file, AIA.config.prompts.extname) }
       fzf = AIA::Fzf.new(
         list: role_files,
         directory: @prompts_dir,

data/lib/aia/robot_builder.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# lib/aia/robot_builder.rb
+#
+# Builds a single RobotLab::Robot from AIA configuration.
+# Extracted from RobotFactory to isolate single-robot construction.
+
+module AIA
+  class RobotBuilder
+    class << self
+      # Build a single robot for one model spec.
+      #
+      # @param config [AIA::Config]
+      # @param namer [RobotNamer]
+      # @return [RobotLab::Robot]
+      def build(config, namer:)
+        model_spec    = config.models.first
+        robot_name    = namer.name_for(model_spec.name)
+        roster        = [{ name: robot_name, spec: model_spec }]
+        identity      = SystemPromptAssembler.build_identity_prompt(robot_name, model_spec, roster)
+        base_prompt   = SystemPromptAssembler.resolve_system_prompt(config, model_spec)
+        thinking_note = thinking_mode_instruction(model_spec)
+        system_prompt = [identity, base_prompt, thinking_note].compact.join("\n\n")
+
+        RobotFactory.build_robot(
+          model_spec,
+          name:          robot_name,
+          system_prompt: system_prompt,
+          local_tools:   ToolLoader.filtered_tools(config),
+          mcp_servers:   RobotFactory.mcp_server_configs(config),
+          on_content:    nil,
+          config:        RobotFactory.build_run_config(config)
+        )
+      end
+
+      private
+
+      # Local thinking-mode models (e.g. qwen3 on Ollama) sometimes generate
+      # reasoning content but leave the response section empty, causing the user
+      # to receive only raw thinking text. This instruction nudges the model to
+      # always emit a plain-text answer after its reasoning.
+      def thinking_mode_instruction(model_spec)
+        return nil unless model_spec&.local_provider?
+
+        "After completing your reasoning, always write a clear, complete response " \
+          "in plain text. Never leave your response empty after thinking — your " \
+          "answer must appear outside the thinking block."
+      end
+    end
+  end
+end