aia 1.1.1 → 2.0.0.0.pre.beta2

data/lib/aia/directives/execution_directives.rb

@@ -1,15 +1,29 @@
+# frozen_string_literal: true
+
 # lib/aia/directives/execution_directives.rb
 
 require 'shellwords'
 
 module AIA
   class ExecutionDirectives < Directive
-    desc "Execute Ruby code"
+    state_setting! :concurrent, :conc, :verify, :decompose, :debate,
+                   :delegate, :del, :spawn, :orchestrate, :orch,
+                   :add_recruit, :add, :drop_recruit, :drop, :reskill
+
+    desc "Execute Ruby code (requires allow_ruby_eval: true in config)"
     def ruby(args, context_manager = nil)
+      unless AIA.config.flags.allow_ruby_eval
+        puts "ERROR: /ruby is disabled. Set `allow_ruby_eval: true` in " \
+             "~/.aia/config.yml or pass --allow-ruby-eval to enable it. " \
+             "Note: this executes arbitrary Ruby with full process privileges."
+        return ""
+      end
+
       ruby_code = args.join(' ')
+      $stderr.puts "WARNING: /ruby executing: #{ruby_code}"
 
       begin
-        String(eval(ruby_code))
+        String(eval(ruby_code))  # rubocop:disable Security/Eval
       rescue StandardError => e
         <<~ERROR
           This ruby code failed: #{ruby_code}
@@ -17,12 +31,135 @@ module AIA
         ERROR
       end
     end
-    alias_method :rb, :ruby
+    alias rb ruby
 
     desc "Use text-to-speech to speak the text"
     def say(args, context_manager = nil)
-      system('say', *args)
+      audio = AIA.config.audio
+      voice = audio.voice
+      env   = {}
+      env['SPEECH_MODEL'] = audio.speech_model if audio.speech_model
+      if voice && !voice.strip.empty?
+        system(env, 'say', '-v', voice, *args)
+      else
+        system(env, 'say', *args)
+      end
       ""
     end
+
+    desc "Execute next prompt with concurrent MCP server access"
+    def concurrent(args, context_manager = nil)
+      AIA.turn_state.force_concurrent_mcp = true
+      "Concurrent MCP mode enabled for next prompt."
+    end
+    alias conc concurrent
+
+    desc "Run next prompt through verification (two independent answers + reconciliation)"
+    def verify(args, context_manager = nil)
+      AIA.turn_state.force_verify = true
+      "Verification mode enabled for next prompt."
+    end
+
+    desc "Decompose next prompt into parallel sub-tasks"
+    def decompose(args, context_manager = nil)
+      AIA.turn_state.force_decompose = true
+      "Decomposition mode enabled for next prompt."
+    end
+
+    desc "Multi-round debate between robots in the network"
+    def debate(args, context_manager = nil)
+      AIA.turn_state.force_debate = true
+      "Debate mode enabled for next prompt."
+    end
+
+    desc "Delegate subtasks to specific robots via TrakFlow plan"
+    def delegate(args, context_manager = nil)
+      AIA.turn_state.force_delegate = true
+      "Delegation mode enabled for next prompt."
+    end
+    alias del delegate
+
+    desc "Spawn a specialist robot for the next prompt. " \
+         "Usage: /spawn  |  /spawn <type>  |  /spawn <name> <provider/model> <system prompt>"
+    def spawn(args, context_manager = nil)
+      state = AIA.turn_state
+      state.force_spawn = true
+
+      if args.size >= 2
+        spec = AIA::SpawnSpecParser.parse(args)
+        state.spawn_spec = spec
+        state.spawn_type = nil
+        "Spawn mode enabled: '#{spec[:name]}' (#{spawn_model_summary(spec)}) for next prompt."
+      else
+        type = args.first
+        state.spawn_spec = nil
+        state.spawn_type = type
+        type_msg = type ? " (#{type})" : " (auto-detect)"
+        "Spawn mode enabled#{type_msg} for next prompt."
+      end
+    end
+
+    desc "Recruit a robot into the crew (persists, @mention-able). Usage: " \
+         "/add_recruit <name> [provider/model] [skill:<id>...] [system prompt]  (alias: /add)"
+    def add_recruit(args, context_manager = nil)
+      return "Usage: /add_recruit <name> [provider/model] [skill:<id> ...] [system prompt]" if args.empty?
+
+      spec = args.size >= 2 ? AIA::SpawnSpecParser.parse(args) : { name: args[0] }
+      robot = AIA::Crew.recruit(spec)
+      "Recruited '#{robot.name}' into the crew (#{recruit_summary(spec)})."
+    rescue AIA::CrewError => e
+      "Recruit failed: #{e.message}"
+    end
+    alias add add_recruit
+
+    desc "Drop a robot from the crew. Usage: /drop_recruit <name>  (alias: /drop)"
+    def drop_recruit(args, context_manager = nil)
+      return "Usage: /drop_recruit <name>" if args.empty?
+
+      AIA::Crew.drop(args.first)
+      "Dropped '#{args.first}' from the crew."
+    rescue AIA::CrewError => e
+      "Drop failed: #{e.message}"
+    end
+    alias drop drop_recruit
+
+    desc "Reset a crew member to a clean slate and re-skill it. " \
+         "Usage: /reskill <name> [skill:<id>...] [system prompt]"
+    def reskill(args, context_manager = nil)
+      return "Usage: /reskill <name> [skill:<id> ...] [system prompt]" if args.empty?
+
+      skills, rest = AIA::SpawnSpecParser.extract_skills(args[1..].to_a)
+      prompt = rest.join(' ').strip
+      robot = AIA::Crew.reskill(args.first, skills: skills, system_prompt: (prompt.empty? ? nil : prompt))
+      suffix = skills.empty? ? '' : " with #{skills.join(', ')}"
+      "Reskilled '#{robot.name}'#{suffix} (clean slate)."
+    rescue AIA::CrewError => e
+      "Reskill failed: #{e.message}"
+    end
+
+    desc "3-tier layered orchestration: orchestrator → lead agents → specialists"
+    def orchestrate(args, context_manager = nil)
+      AIA.turn_state.force_orchestrate = true
+      "Orchestration mode enabled. Your next prompt is the application requirements."
+    end
+    alias orch orchestrate
+
+    private
+
+    # Human-readable model description for the /spawn confirmation message.
+    def spawn_model_summary(spec)
+      model = spec[:model]
+      return 'inherited model' unless model
+
+      spec[:provider] ? "#{spec[:provider]}/#{model}" : model
+    end
+
+    # Model plus any assigned skills, for the /add_recruit confirmation message.
+    def recruit_summary(spec)
+      parts  = [spawn_model_summary(spec)]
+      skills = Array(spec[:skills])
+      parts << "skills: #{skills.join(', ')}" unless skills.empty?
+      parts.join('; ')
+    end
   end
 end

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,16 +22,36 @@ 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"
     def compare(args, context_manager = nil)
-      return 'Error: No prompt provided for comparison' if args.empty?
+      prompt, models = parse_compare_args(args)
+
+      return report_error('Error: No prompt provided for comparison') unless prompt
+      return report_error('Error: No models specified. Use --models model1,model2,model3') if models.empty?
+
+      puts "\nComparing responses for: #{prompt}\n"
+      puts '=' * 80
+
+      models.each { |model_name| compare_with_model(model_name.strip, prompt) }
 
+      puts "\n" + ('=' * 80)
+      puts "\nComparison complete!"
+
+      ''
+    end
+    alias cmp compare
+
+    # --- helpers (no desc → not registered) ---
+
+    # Split a //compare arg list into [prompt, models]; the first non-flag
+    # token is the prompt, `--models a,b,c` supplies the model list.
+    def parse_compare_args(args)
       prompt = nil
       models = []
 
@@ -46,46 +66,33 @@ module AIA
         end
       end
 
-      return 'Error: No prompt provided for comparison' unless prompt
-      return 'Error: No models specified. Use --models model1,model2,model3' if models.empty?
-
-      puts "\nComparing responses for: #{prompt}\n"
-      puts '=' * 80
-
-      results = {}
-
-      models.each do |model_name|
-        model_name.strip!
-        puts "\n🤖 **#{model_name}:**"
-        puts '-' * 40
-
-        begin
-          chat = RubyLLM.chat(model: model_name)
-          response = chat.ask(prompt)
-          content = response.content
+      [prompt, models]
+    end
 
-          puts content
-          results[model_name] = content
-        rescue StandardError => e
-          error_msg = "Error with #{model_name}: #{e.message}"
-          puts error_msg
-          results[model_name] = error_msg
-        end
-      end
+    def compare_with_model(model_name, prompt)
+      puts "\n🤖 **#{model_name}:**"
+      puts '-' * 40
 
-      puts '\n' + '=' * 80
-      puts "\nComparison complete!"
-
-      ''
+      response = RubyLLM.chat(model: model_name).ask(prompt)
+      puts response.content
+    rescue StandardError => e
+      puts "Error with #{model_name}: #{e.message}"
     end
-    alias_method :cmp, :compare
 
-    # --- helpers (no desc → not registered) ---
+    # Log and print a directive error, then return nil so the chat loop
+    # skips forwarding it to the robot (an error is not conversational output).
+    def report_error(msg)
+      AIA::LoggerManager.aia_logger.error(msg)
+      puts msg
+      nil
+    end
 
-    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,144 +108,159 @@ module AIA
       end
     end
 
-    def show_ollama_models(api_base, positive_terms, negative_terms)
-      begin
-        uri = URI("#{api_base}/api/tags")
-        response = Net::HTTP.get_response(uri)
-
-        unless response.is_a?(Net::HTTPSuccess)
-          puts "❌ Cannot connect to Ollama at #{api_base}"
-          return
-        end
-
-        data = JSON.parse(response.body)
-        models = data['models'] || []
+    # :reek:TooManyStatements -- sequential terminal report: fetch, connection guards, filtered listing
+    def show_ollama_models(api_base, positive_terms = nil, negative_terms = nil)
+      positive_terms, negative_terms = normalized_model_search_terms(positive_terms, negative_terms)
 
-        if models.empty?
-          puts "No Ollama models found"
-          return
-        end
+      data = fetch_json("#{api_base}/api/tags")
+      if data.nil?
+        puts "❌ Cannot connect to Ollama at #{api_base}"
+        return
+      end
 
-        puts "Ollama Models (#{api_base}):"
-        puts "-" * 60
+      models = data['models'] || []
+      if models.empty?
+        puts "No Ollama models found"
+        return
+      end
 
-        counter = 0
-        models.each do |model|
-          name = model['name']
-          size = model['size'] ? format_bytes(model['size']) : 'unknown'
-          modified = model['modified_at'] ? Time.parse(model['modified_at']).strftime('%Y-%m-%d') : 'unknown'
+      puts "Ollama Models (#{api_base}):"
+      puts "-" * 60
 
-          entry = "- ollama/#{name} (size: #{size}, modified: #{modified})"
-          entry_down = entry.downcase
+      entries = models.map { |model| format_ollama_entry(model) }
+      print_filtered_entries(entries, positive_terms, negative_terms, "Ollama model(s) available")
+    rescue StandardError => e
+      puts "❌ Error fetching Ollama models: #{e.message}"
+    end
 
-          show_it = positive_terms.empty? || positive_terms.any? { |q| entry_down.include?(q) }
-          show_it &&= negative_terms.none? { |q| entry_down.include?(q) }
+    def format_ollama_entry(model)
+      size     = model['size'] ? format_bytes(model['size']) : 'unknown'
+      modified = model['modified_at'] ? Time.parse(model['modified_at']).strftime('%Y-%m-%d') : 'unknown'
+      "- ollama/#{model['name']} (size: #{size}, modified: #{modified})"
+    end
 
-          if show_it
-            puts entry
-            counter += 1
-          end
-        end
+    # Fetch and parse JSON from a local model server; nil unless HTTP success.
+    def fetch_json(uri_string)
+      uri  = URI(uri_string)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.open_timeout = 5
+      http.read_timeout = 5
+      response = http.request(Net::HTTP::Get.new(uri))
+      return nil unless response.is_a?(Net::HTTPSuccess)
 
-        puts
-        puts "#{counter} Ollama model(s) available"
-        puts
-      rescue StandardError => e
-        puts "❌ Error fetching Ollama models: #{e.message}"
-      end
+      JSON.parse(response.body)
     end
 
-    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)
+    # The entry is a String; Array#intersect? would raise TypeError
+    def entry_matches?(entry_lc, positive_terms, negative_terms)
+      (positive_terms.empty? || positive_terms.any? { |q| entry_lc.include?(q) }) &&
+        negative_terms.none? { |q| entry_lc.include?(q) }
+    end
 
-        unless response.is_a?(Net::HTTPSuccess)
-          puts "❌ Cannot connect to LM Studio at #{api_base}"
-          return
-        end
+    def print_filtered_entries(entries, positive_terms, negative_terms, summary_label)
+      counter = 0
+      entries.each do |entry|
+        next unless entry_matches?(entry.downcase, positive_terms, negative_terms)
 
-        data = JSON.parse(response.body)
-        models = data['data'] || []
+        puts entry
+        counter += 1
+      end
 
-        if models.empty?
-          puts "No LM Studio models found"
-          return
-        end
+      puts
+      puts "#{counter} #{summary_label}"
+      puts
+    end
 
-        puts "LM Studio Models (#{api_base}):"
-        puts "-" * 60
+    # :reek:TooManyStatements -- sequential terminal report: fetch, connection guards, filtered listing
+    def show_lms_models(api_base, positive_terms = nil, negative_terms = nil)
+      positive_terms, negative_terms = normalized_model_search_terms(positive_terms, negative_terms)
 
-        counter = 0
-        models.each do |model|
-          name = model['id']
-          entry = "- lms/#{name}"
-          entry_down = entry.downcase
+      data = fetch_json("#{api_base.gsub(%r{/v1/?$}, '')}/v1/models")
+      if data.nil?
+        puts "❌ Cannot connect to LM Studio at #{api_base}"
+        return
+      end
 
-          show_it = positive_terms.empty? || positive_terms.any? { |q| entry_down.include?(q) }
-          show_it &&= negative_terms.none? { |q| entry_down.include?(q) }
+      models = data['data'] || []
+      if models.empty?
+        puts "No LM Studio models found"
+        return
+      end
 
-          if show_it
-            puts entry
-            counter += 1
-          end
-        end
+      puts "LM Studio Models (#{api_base}):"
+      puts "-" * 60
 
-        puts
-        puts "#{counter} LM Studio model(s) available"
-        puts
-      rescue StandardError => e
-        puts "❌ Error fetching LM Studio models: #{e.message}"
-      end
+      entries = models.map { |model| "- lms/#{model['id']}" }
+      print_filtered_entries(entries, positive_terms, negative_terms, "LM Studio model(s) available")
+    rescue StandardError => e
+      puts "❌ Error fetching LM Studio models: #{e.message}"
     end
 
     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_') }
+    # :reek:TooManyStatements -- sequential terminal report: header, filtered model listing, summary
+    def show_rubyllm_models(positive_terms = nil, negative_terms = nil)
+      positive_terms, negative_terms = normalized_model_search_terms(positive_terms, negative_terms)
 
-      header = "\nAvailable LLMs"
-      header += " for #{positive_terms.join(' and ')}" unless positive_terms.empty?
-      header += " excluding: #{negative_terms.join(', ')}" unless negative_terms.empty?
+      # expand comma-separated terms passed as a single token
+      positive_terms = positive_terms.first.split(',') if positive_terms.size == 1
 
-      puts header + ':'
+      puts rubyllm_header(positive_terms, negative_terms)
       puts
 
-      counter = 0
+      # modality terms (e.g. "text_to_text") trigger capability checks; the rest
+      # are plain substring filters applied to the formatted entry string
+      modality_terms, substring_terms = positive_terms.partition { |q| q.include?('_to_') }
 
+      counter = 0
       RubyLLM.models.all.each do |llm|
-        cw = llm.context_window
-        caps = llm.capabilities.join(',')
-        inputs = llm.modalities.input.join(',')
-        outputs = llm.modalities.output.join(',')
-        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
-
-        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) }
-
-        if show_it
-          counter += 1
-          puts entry
-        end
+        entry = format_rubyllm_entry(llm)
+        next unless rubyllm_entry_visible?(llm, entry, modality_terms, substring_terms, negative_terms)
+
+        counter += 1
+        puts entry
       end
 
-      puts if counter > 0
+      puts if counter.positive?
       puts "#{counter} LLMs matching your query"
       puts
     end
+
+    def rubyllm_header(positive_terms, negative_terms)
+      header = "\nAvailable LLMs"
+      header += " for #{positive_terms.join(' and ')}" if positive_terms.any?
+      header += " (excluding: #{negative_terms.join(', ')})" if negative_terms.any?
+      header + ':'
+    end
+
+    def format_rubyllm_entry(llm)
+      modalities = llm.modalities
+      mode  = "#{modalities.input.join(',')} to #{modalities.output.join(',')}"
+      in_1m = llm.pricing.text_tokens.standard.to_h[:input_per_million]
+      "- #{llm.id} (#{llm.provider}) in: $#{in_1m} cw: #{llm.context_window} mode: #{mode} caps: #{llm.capabilities.join(',')}"
+    end
+
+    def rubyllm_entry_visible?(llm, entry, modality_terms, substring_terms, negative_terms)
+      modality_terms.all? { |q| llm.modalities.send("#{q}?") } &&
+        substring_terms.all? { |q| entry.include?(q) } &&
+        negative_terms.none? { |q| entry.downcase.include?(q) }
+    end
+
+    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,62 @@
+# 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 report_error("TrakFlow not available. Run 'tf init' to initialize a project.") unless bridge.available?
+
+      if args.first == "summary"
+        bridge.project_summary || report_status("No summary available.")
+      else
+        bridge.check_ready_tasks || report_status("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 report_error("TrakFlow not available. Run 'tf init' to initialize a project.") unless bridge.available?
+
+      description = args.join(' ')
+      return report_error("Usage: /plan <description>") if description.empty?
+
+      bridge.create_task(description) || report_error("Failed to create plan.")
+    end
+
+    desc "Create a TrakFlow task"
+    def task(args, context_manager = nil)
+      bridge = TrakFlowBridge.new
+      return report_error("TrakFlow not available. Run 'tf init' to initialize a project.") unless bridge.available?
+
+      title = args.join(' ')
+      return report_error("Usage: /task <title>") if title.empty?
+
+      bridge.create_task(title) || report_error("Failed to create task.")
+    end
+
+    private
+
+    # Log and print a directive error, then return nil so the chat loop
+    # skips forwarding it to the robot (an error is not conversational output).
+    def report_error(msg)
+      AIA::LoggerManager.aia_logger.error(msg)
+      puts msg
+      nil
+    end
+
+    # Same as report_error, but for a non-error empty-result status
+    # (e.g. "no ready tasks found") rather than a failure.
+    def report_status(msg)
+      AIA::LoggerManager.aia_logger.info(msg)
+      puts msg
+      nil
+    end
+  end
+end