aia 1.1.1 → 2.0.0.0.pre.alpha

data/lib/aia/directives/web_and_file_directives.rb

@@ -2,13 +2,11 @@
 
 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"
@@ -23,20 +21,20 @@ module AIA
           req.headers['x-puremd-api-token'] = PUREMD_API_KEY
         end
 
-        if 200 == response.status
+        if response.status == 200
           response.body
         else
           "Error: Status was #{response.status}\n#{ap response}"
         end
       end
     end
-    alias_method :website, :webpage
-    alias_method :web,     :webpage
+    alias website webpage
+    alias web webpage
 
     desc "List available AIA skills"
+    # rubocop:disable Metrics/AbcSize
     def skills(args = [], _context_manager = nil)
       dir = aia_skills_dir
-
       unless Dir.exist?(dir)
         puts "No skills directory found at #{dir}"
         return nil
@@ -44,74 +42,56 @@ module AIA
 
       positive_terms, negative_terms = parse_search_terms(Array(args))
 
-      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
+      skill_dirs = Dir.children(dir).select do |e|
+        File.directory?(File.join(dir, e)) &&
+          File.exist?(File.join(dir, e, 'SKILL.md'))
       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"
+      entries = 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
+
+      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
+      wrap_width = terminal_width - 2
+
+      entries.each do |skill_id|
+        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
 
-      puts "\nTotal: #{skill_data.size} skill#{'s' if skill_data.size != 1}"
       nil
     end
+    # rubocop:enable Metrics/AbcSize
 
-    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")
+        msg = "Error: /skill requires a skill name. Use /skills to list available skills."
+        AIA::LoggerManager.aia_logger.error(msg)
+        puts msg
         return nil
       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
+        msg = "Error: No skill matching '#{skill_name}' found in #{dir}. Use /skills to list available skills."
+        AIA::LoggerManager.aia_logger.error(msg)
+        puts msg
         return nil
       end
 
@@ -119,8 +99,13 @@ module AIA
 
       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")
+        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
+        AIA::LoggerManager.aia_logger.error(msg)
+        puts msg
         return nil
       end
 
@@ -134,19 +119,70 @@ module AIA
     rescue StandardError => e
       "Error: Unable to paste from clipboard - #{e.message}"
     end
-    alias_method :clipboard, :paste
+    alias clipboard paste
 
     private
 
+    # Resolve the AIA skills directory from config, env vars, or defaults.
     def aia_skills_dir
-      AIA.config.skills.dir
+      if AIA.respond_to?(:config) && AIA.config&.skills.respond_to?(:dir) && AIA.config.skills.dir
+        return AIA.config.skills.dir
+      end
+
+      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

data/lib/aia/handler_protocol.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# lib/aia/handler_protocol.rb
+#
+# Uniform interface for all turn-level handlers.
+# Include this module and implement handle(context) where context
+# is an AIA::HandlerContext value object.
+
+module AIA
+  module HandlerProtocol
+    # Process a turn. Each handler reads only the context fields it needs.
+    #
+    # @param context [AIA::HandlerContext]
+    # @return handler-specific result (String content, Boolean, or nil)
+    def handle(context)
+      raise NotImplementedError, "#{self.class} must implement #handle(context)"
+    end
+  end
+end

data/lib/aia/history_transfer.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# lib/aia/history_transfer.rb
+#
+# Stateless module for transferring conversation history between robots.
+# Extracted from RobotFactory to isolate the history transfer concern.
+
+module AIA
+  module HistoryTransfer
+    module_function
+
+    # Replay conversation history from an old robot to a new one.
+    #
+    # Performance: O(N) API calls where N = number of user messages.
+    # Each user message triggers a full LLM round-trip on the new model.
+    # For a 10-turn conversation with a local model (~1s/turn), expect ~10s.
+    # For a cloud model (~2-5s/turn), expect 20-50s. MCP/tools are disabled
+    # during replay to avoid side effects.
+    def replay_history(old_robot, new_robot)
+      return unless old_robot.respond_to?(:messages)
+
+      old_robot.messages.each do |msg|
+        next unless msg.respond_to?(:role) && msg.role == :user
+        new_robot.run(msg.content, mcp: :none, tools: :none)
+      end
+    rescue StandardError => e
+      $stderr.puts "Warning: History replay failed: #{e.message}"
+    end
+
+    # Summarize conversation history and inject into new robot.
+    #
+    # Performance: Exactly 2 API calls regardless of conversation length.
+    # 1) Summarize on old model (input tokens proportional to conversation)
+    # 2) Inject summary into new model (small fixed-size prompt)
+    # Faster than :replay for conversations with >2 turns, but loses
+    # per-turn context fidelity. Total latency ~4-10s for cloud models.
+    def summarize_history(old_robot, new_robot)
+      return unless old_robot.respond_to?(:messages) && old_robot.messages.any?
+
+      summary_lines = old_robot.messages.map do |msg|
+        "#{msg.role}: #{msg.content}" if msg.respond_to?(:role)
+      end.compact
+
+      return if summary_lines.empty?
+
+      summary_prompt = "Summarize this conversation concisely for context transfer:\n#{summary_lines.join("\n")}"
+      summary = old_robot.run(summary_prompt, mcp: :none, tools: :none)
+      content = summary.respond_to?(:reply) ? summary.reply : summary.to_s
+
+      new_robot.run("Context from previous conversation: #{content}", mcp: :none, tools: :none)
+    rescue StandardError => e
+      $stderr.puts "Warning: History summarization failed: #{e.message}"
+    end
+  end
+end

data/lib/aia/input_collector.rb

@@ -3,17 +3,17 @@
 
 module AIA
   class InputCollector
-    # Collect variable values from user input via HistoryManager
+    # Collect variable values from user input via VariableInputCollector
     def collect(parameters)
       return {} if parameters.nil? || parameters.empty?
 
       values = {}
-      input_manager = AIA::HistoryManager.new
+      input_manager = AIA::VariableInputCollector.new
 
       parameters.each do |name, default|
         value = input_manager.request_variable_value(
           variable_name: name,
-          default_value: default,
+          default_value: default
         )
         values[name] = value
       end