aia 1.1.1 → 2.0.0.0.pre.alpha

data/lib/aia/directives/configuration_directives.rb

@@ -2,45 +2,46 @@
 
 module AIA
   class ConfigurationDirectives < Directive
+    state_setting! :model
+
     desc "View or set configuration values"
     def config(args = [], context_manager = nil)
       args = Array(args)
 
       if args.empty?
         ap AIA.config.to_h
-        ""
       elsif args.length == 1
         config_item = args.first
         local_cfg = {}
-        if AIA.config.respond_to?(config_item)
-          local_cfg[config_item] = AIA.config.send(config_item)
-        else
-          local_cfg[config_item] = nil
-        end
+        local_cfg[config_item] = if AIA.config.respond_to?(config_item)
+                                   AIA.config.send(config_item)
+                                 end
         ap local_cfg
-        ""
       else
         config_item = args.shift
-        boolean = AIA.respond_to?("#{config_item}?")
-        new_value = args.join(' ').gsub('=', '').strip
+        new_value   = args.join(' ').gsub('=', '').strip
 
+        # Resolve the leaf key name regardless of dot-notation (flags.debug → debug)
+        leaf_key = config_item.to_s.split('.').last
+
+        boolean = AIA.respond_to?("#{leaf_key}?")
         if boolean
           new_value = %w[true t yes y on 1 yea yeah yep yup].include?(new_value.downcase)
         end
 
-        setter = "#{config_item}="
-        if AIA.config.respond_to?(setter)
-          AIA.config.send(setter, new_value)
+        if write_config_value(config_item, new_value)
+          AIA::LoggerManager.reconfigure_levels!
         else
-          warn "Warning: Unknown config option '#{config_item}'"
+          $stderr.puts "Warning: Unknown config option '#{config_item}'"
           AIA::LoggerManager.aia_logger.warn("Unknown config option '#{config_item}'")
         end
-        ""
       end
+      ""
     end
-    alias_method :cfg, :config
+    alias cfg config
 
     desc "View or change the AI model"
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
     def model(args, context_manager = nil)
       if args.empty?
         puts
@@ -49,7 +50,13 @@ module AIA
         if models.size == 1
           puts "Current Model:"
           puts "=============="
-          puts AIA.client.model.to_h.pretty_inspect
+          model_name = models.first.respond_to?(:name) ? models.first.name : models.first.to_s
+          begin
+            model_info = RubyLLM::Models.find(model_name)
+            puts model_info.to_h.pretty_inspect if model_info
+          rescue StandardError
+            puts "  #{model_name}"
+          end
         else
           puts "Multi-Model Configuration:"
           puts "=========================="
@@ -64,7 +71,7 @@ module AIA
 
           models.each_with_index do |model_spec, index|
             model_name = model_spec.respond_to?(:name) ? model_spec.name : model_spec.to_s
-            puts "#{index + 1}. #{model_name}#{index == 0 ? ' (primary)' : ''}"
+            puts "#{index + 1}. #{model_name}#{' (primary)' if index.zero?}"
 
             begin
               model_info = RubyLLM::Models.find(model_name)
@@ -88,22 +95,155 @@ module AIA
       else
         model_names = args.join(' ').split(',').map(&:strip).reject(&:empty?)
         AIA.config.models = AIA::Config::TO_MODEL_SPECS.call(model_names)
-        AIA.client = AIA.client.class.new
+        AIA.client = RobotFactory.rebuild(AIA.config)
       end
 
       ''
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
     desc "Set the temperature parameter for AI responses"
     def temperature(args, context_manager = nil)
       config(args.prepend('temperature'), context_manager)
     end
-    alias_method :temp, :temperature
+    alias temp temperature
 
     desc "Set the top_p parameter for AI responses"
     def top_p(args, context_manager = nil)
       config(args.prepend('top_p'), context_manager)
     end
-    alias_method :topp, :top_p
+    alias topp top_p
+
+    desc "Dump session cost/token metrics as CSV"
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+    def cost(args = [], context_manager = nil)
+      tracker = AIA.session_tracker
+      unless tracker
+        puts "No session tracker available."
+        return ''
+      end
+
+      turns = tracker.turns.reject { |t| t[:type] == :model_switch }
+      if turns.empty?
+        puts "No turns recorded yet."
+        return ''
+      end
+
+      has_similarity = turns.any? { |t| t.key?(:similarity) }
+
+      header = %w[model input_tokens output_tokens total_tokens cost elapsed]
+      header << 'similarity' if has_similarity
+      lines  = [header.join(',')]
+
+      turns.each do |turn|
+        input_t  = turn[:input_tokens] || 0
+        output_t = turn[:output_tokens] || 0
+        total_t  = input_t + output_t
+        cost_val = turn[:cost] || 0.0
+        elapsed  = turn[:elapsed] || 0
+
+        row = [
+          turn[:model],
+          input_t,
+          output_t,
+          total_t,
+          "$#{'%.5f' % cost_val}",
+          "%.1fs" % elapsed
+        ]
+
+        if has_similarity
+          sim = turn[:similarity]
+          row << (sim.nil? ? 'ref' : "%.1f%%" % (sim * 100))
+        end
+
+        lines << row.join(',')
+      end
+
+      # Totals
+      total_input   = turns.sum { |t| t[:input_tokens] || 0 }
+      total_output  = turns.sum { |t| t[:output_tokens] || 0 }
+      total_tokens  = total_input + total_output
+      total_cost    = turns.sum { |t| t[:cost] || 0.0 }
+      max_elapsed   = turns.map { |t| t[:elapsed] || 0 }.max
+
+      totals = [
+        'TOTAL',
+        total_input,
+        total_output,
+        total_tokens,
+        "$#{'%.5f' % total_cost}",
+        "%.1fs" % max_elapsed
+      ]
+      totals << '' if has_similarity
+      lines << totals.join(',')
+
+      csv = lines.join("\n")
+      puts
+      puts csv
+      puts
+
+      out_file = AIA.config.output&.file
+      File.open(out_file, 'a') { |f| f.puts csv } if out_file
+
+      ''
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+    private
+
+    # Apply a config value by key, supporting three forms:
+    #   flat CLI key  — "debug"        → CLI_TO_NESTED_MAP routing
+    #   dot-notation  — "flags.debug"  → navigate section.subkey
+    #   direct setter — "log_level_override" → AIA.config.<key>=
+    #
+    # Returns true if the value was set, false if the key was unknown.
+    def write_config_value(config_item, new_value) # rubocop:disable Naming/PredicateMethod
+      key_str = config_item.to_s
+
+      # Dot-notation: walk the config object by path segments
+      if key_str.include?('.')
+        parts   = key_str.split('.')
+        obj     = AIA.config
+        parents = parts[0..-2]
+        leaf    = parts.last
+
+        parents.each do |part|
+          obj = obj.respond_to?(part) ? obj.send(part) : nil
+          return false if obj.nil?
+        end
+
+        if obj.respond_to?("#{leaf}=")
+          obj.send("#{leaf}=", new_value)
+          maybe_clear_log_override(leaf, new_value)
+          return true
+        end
+        return false
+      end
+
+      # Flat CLI key via CLI_TO_NESTED_MAP (e.g. "debug" → flags.debug)
+      if AIA::Config::CLI_TO_NESTED_MAP.key?(key_str.to_sym) &&
+         AIA.config.respond_to?(:apply_overrides)
+        AIA.config.apply_overrides({ key_str.to_sym => new_value })
+        maybe_clear_log_override(key_str, new_value)
+        return true
+      end
+
+      # Direct setter on the config object (e.g. "log_level_override")
+      if AIA.config.respond_to?("#{key_str}=")
+        AIA.config.send("#{key_str}=", new_value)
+        return true
+      end
+
+      false
+    end
+
+    # When debug is disabled, clear log_level_override so the logger
+    # drops back to its configured level rather than staying at DEBUG.
+    def maybe_clear_log_override(key, value)
+      return unless key.to_s == 'debug' && value == false
+      return unless AIA.config.respond_to?(:log_level_override=)
+
+      AIA.config.log_level_override = nil if AIA.config.log_level_override.to_s == 'debug'
+    end
   end
 end

data/lib/aia/directives/context_directives.rb

@@ -5,6 +5,8 @@
 
 module AIA
   class ContextDirectives < Directive
+    state_setting! :clear, :checkpoint, :ckp, :cp, :restore, :review, :context
+
     attr_accessor :checkpoint_store, :checkpoint_counter, :last_checkpoint_name
 
     def initialize
@@ -32,9 +34,9 @@ module AIA
 
       first_chat_messages = chats.values.first&.messages || []
       @checkpoint_store[name] = {
-        messages: chats.transform_values { |chat|
+        messages: chats.transform_values do |chat|
           chat.messages.map { |msg| deep_copy_message(msg) }
-        },
+        end,
         position: first_chat_messages.size,
         created_at: Time.now,
         topic_preview: extract_last_user_message(first_chat_messages)
@@ -44,8 +46,8 @@ module AIA
       puts "Checkpoint '#{name}' created at position #{@checkpoint_store[name][:position]}."
       ""
     end
-    alias_method :ckp, :checkpoint
-    alias_method :cp,  :checkpoint
+    alias ckp checkpoint
+    alias cp checkpoint
 
     desc "Restore context to a previous checkpoint"
     def restore(args, _unused = nil)
@@ -64,16 +66,16 @@ module AIA
       end
 
       checkpoint_data = @checkpoint_store[name]
-      chats = get_chats
+      robots = get_robots
 
-      return "Error: No active chat sessions found." if chats.nil? || chats.empty?
+      return "Error: No active chat sessions found." if robots.nil? || robots.empty?
 
       checkpoint_data[:messages].each do |model_id, saved_messages|
-        chat = chats[model_id]
-        next unless chat
+        robot = robots[model_id]
+        next unless robot
 
         restored_messages = saved_messages.map { |msg| deep_copy_message(msg) }
-        chat.instance_variable_set(:@messages, restored_messages)
+        robot.replace_messages(restored_messages)
       end
 
       restored_position = checkpoint_data[:position]
@@ -82,7 +84,7 @@ module AIA
       @last_checkpoint_name = name
 
       msg = "Context restored to checkpoint '#{name}' (position #{restored_position})."
-      msg += " Removed #{removed_count} checkpoint(s) that were beyond this position." if removed_count > 0
+      msg += " Removed #{removed_count} checkpoint(s) that were beyond this position." if removed_count.positive?
       msg
     end
 
@@ -90,17 +92,11 @@ module AIA
     def clear(args, _unused = nil)
       keep_system = !args.include?('--all')
 
-      chats = get_chats
-      return "Error: No active chat sessions found." if chats.nil? || chats.empty?
+      robots = get_robots
+      return "Error: No active chat sessions found." if robots.nil? || robots.empty?
 
-      chats.each do |_model_id, chat|
-        if keep_system
-          system_msg = chat.messages.find { |m| m.role == :system }
-          chat.instance_variable_set(:@messages, [])
-          chat.add_message(system_msg) if system_msg
-        else
-          chat.instance_variable_set(:@messages, [])
-        end
+      robots.each_value do |robot|
+        robot.clear_messages(keep_system: keep_system)
       end
 
       @checkpoint_store.clear
@@ -111,6 +107,7 @@ module AIA
     end
 
     desc "Display the current conversation context with checkpoint markers"
+    # rubocop:disable Metrics/AbcSize
     def review(args, _unused = nil)
       chats = get_chats
       return "Error: No active chat sessions found." if chats.nil? || chats.empty?
@@ -147,7 +144,8 @@ module AIA
       puts "=== End of Context ==="
       ""
     end
-    alias_method :context, :review
+    # rubocop:enable Metrics/AbcSize
+    alias context review
 
     desc "List all available checkpoints"
     def checkpoints_list(args, _unused = nil)
@@ -167,7 +165,7 @@ module AIA
       puts "=== End of Checkpoints ==="
       ""
     end
-    alias_method :checkpoints, :checkpoints_list
+    alias checkpoints checkpoints_list
 
     # --- helpers (no desc → not registered as directives) ---
 
@@ -200,9 +198,23 @@ module AIA
 
     private
 
+    # In v2, AIA.client is a RobotLab::Robot which wraps a RubyLLM::Chat.
+    # Returns a hash of { name => Robot } for checkpoint operations.
+    def get_robots
+      robot = AIA.client
+      return nil unless robot
+
+      name = robot.respond_to?(:name) ? robot.name : "default"
+      { name => robot }
+    end
+
+    # Return { name => RubyLLM::Chat } for operations that need direct chat access.
+    # Uses Robot#chat public API.
     def get_chats
-      return nil unless AIA.client.respond_to?(:chats)
-      AIA.client.chats
+      robots = get_robots
+      return nil unless robots
+
+      robots.transform_values(&:chat)
     end
 
     def deep_copy_message(msg)
@@ -233,12 +245,12 @@ module AIA
     def extract_last_user_message(messages, max_length: 70)
       return "" if messages.nil? || messages.empty?
 
-      last_user_msg = messages.reverse.find { |msg| msg.role == :user }
+      last_user_msg = messages.rfind { |msg| msg.role == :user }
       return "" unless last_user_msg
 
       content = last_user_msg.content.to_s.strip
       content = content.gsub(/\s+/, ' ')
-      content.length > max_length ? "#{content[0..max_length - 4]}..." : content
+      content.length > max_length ? "#{content[0..(max_length - 4)]}..." : content
     end
   end
 end

data/lib/aia/directives/execution_directives.rb

@@ -1,15 +1,28 @@
+# 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
+        return "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."
+      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 +30,131 @@ 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
+      env   = {}
+      env['SPEECH_MODEL'] = audio.speech_model if audio.speech_model
+      if audio.voice && !audio.voice.strip.empty?
+        system(env, 'say', '-v', audio.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)
+      AIA.turn_state.force_spawn = true
+
+      if args.size >= 2
+        spec = AIA::SpawnSpecParser.parse(args)
+        AIA.turn_state.spawn_spec = spec
+        AIA.turn_state.spawn_type = nil
+        "Spawn mode enabled: '#{spec[:name]}' (#{spawn_model_summary(spec)}) for next prompt."
+      else
+        AIA.turn_state.spawn_spec = nil
+        AIA.turn_state.spawn_type = args.first
+        type_msg = args.first ? " (#{args.first})" : " (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)
+      return 'inherited model' unless spec[:model]
+
+      spec[:provider] ? "#{spec[:provider]}/#{spec[:model]}" : spec[: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