aia 1.1.1 → 2.0.0.0.pre.beta2

data/lib/aia/directives/configuration_directives.rb

@@ -2,93 +2,59 @@
 
 module AIA
   class ConfigurationDirectives < Directive
+    state_setting! :model
+
     desc "View or set configuration values"
+    # :reek:TooManyStatements -- view/set dispatch on arg count, coercing booleans and dot-notation keys before writing
     def config(args = [], context_manager = nil)
       args = Array(args)
+      cfg  = AIA.config
 
       if args.empty?
-        ap AIA.config.to_h
-        ""
+        ap cfg.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 cfg.respond_to?(config_item)
+                                   cfg.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"
     def model(args, context_manager = nil)
+      cfg = AIA.config
+
       if args.empty?
         puts
-        models = AIA.config.models
-
-        if models.size == 1
-          puts "Current Model:"
-          puts "=============="
-          puts AIA.client.model.to_h.pretty_inspect
-        else
-          puts "Multi-Model Configuration:"
-          puts "=========================="
-          puts "Model count: #{models.size}"
-          first_model = models.first.respond_to?(:name) ? models.first.name : models.first.to_s
-          puts "Primary model: #{first_model} (used for consensus when --consensus flag is enabled)"
-          consensus = AIA.config.flags.consensus
-          puts "Consensus mode: #{consensus.nil? ? 'auto-detect (disabled by default)' : consensus}"
-          puts
-          puts "Model Details:"
-          puts "-" * 50
-
-          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)' : ''}"
-
-            begin
-              model_info = RubyLLM::Models.find(model_name)
-              if model_info
-                puts "   Provider: #{model_info.provider || 'Unknown'}"
-                puts "   Context window: #{model_info.context_window || 'Unknown'}"
-                puts "   Input cost: $#{model_info.input_cost || 'Unknown'}"
-                puts "   Output cost: $#{model_info.output_cost || 'Unknown'}"
-                puts "   Mode: #{model_info.modalities || 'Unknown'}"
-                puts "   Capabilities: #{(model_info.capabilities || []).join(', ')}" if model_info.capabilities&.any?
-              else
-                puts "   Details: Model not found in registry"
-              end
-            rescue StandardError => e
-              puts "   Details: Unable to fetch (#{e.class.name}: #{e.message})"
-            end
-            puts
-          end
-        end
+        models = cfg.models
+        models.size == 1 ? show_single_model(models) : show_multi_model(models)
         puts
       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
+        cfg.models = AIA::Config::TO_MODEL_SPECS.call(model_names)
+        AIA.client = RobotFactory.rebuild(cfg)
       end
 
       ''
@@ -98,12 +64,200 @@ module AIA
     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"
+    # :reek:TooManyStatements -- CSV assembly: guards, header, rows, totals, print, optional file append
+    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 { |turn| lines << cost_row(turn, has_similarity).join(',') }
+      lines << cost_totals_row(turns, has_similarity).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
+
+    private
+
+    # One CSV row for a single recorded turn.
+    def cost_row(turn, has_similarity)
+      input_t  = turn[:input_tokens] || 0
+      output_t = turn[:output_tokens] || 0
+
+      row = [
+        turn[:model],
+        input_t,
+        output_t,
+        input_t + output_t,
+        "$#{'%.5f' % (turn[:cost] || 0.0)}",
+        "%.1fs" % (turn[:elapsed] || 0)
+      ]
+
+      if has_similarity
+        sim = turn[:similarity]
+        row << (sim.nil? ? 'ref' : "%.1f%%" % (sim * 100))
+      end
+      row
+    end
+
+    # The TOTAL summary row across all turns.
+    # :reek:DuplicateMethodCall -- each turns.sum aggregates a different field; there is no shared value to hoist
+    def cost_totals_row(turns, has_similarity)
+      total_input  = turns.sum { |t| t[:input_tokens] || 0 }
+      total_output = turns.sum { |t| t[:output_tokens] || 0 }
+      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_input + total_output,
+        "$#{'%.5f' % total_cost}",
+        "%.1fs" % max_elapsed
+      ]
+      totals << '' if has_similarity
+      totals
+    end
+
+    # Format a model spec's display name whether it is a ModelSpec or a bare string.
+    def model_display_name(spec)
+      spec.respond_to?(:name) ? spec.name : spec.to_s
+    end
+
+    def show_single_model(models)
+      puts "Current Model:"
+      puts "=============="
+      model_name = model_display_name(models.first)
+      begin
+        model_info = RubyLLM::Models.find(model_name)
+        puts model_info.to_h.pretty_inspect if model_info
+      rescue StandardError
+        puts "  #{model_name}"
+      end
+    end
+
+    # :reek:TooManyStatements -- sequential terminal report: summary lines then a details block per model
+    def show_multi_model(models)
+      puts "Multi-Model Configuration:"
+      puts "=========================="
+      puts "Model count: #{models.size}"
+      puts "Primary model: #{model_display_name(models.first)} (used for consensus when --consensus flag is enabled)"
+      consensus = AIA.config.flags.consensus
+      puts "Consensus mode: #{consensus.nil? ? 'auto-detect (disabled by default)' : consensus}"
+      puts
+      puts "Model Details:"
+      puts "-" * 50
+
+      models.each_with_index do |model_spec, index|
+        puts "#{index + 1}. #{model_display_name(model_spec)}#{' (primary)' if index.zero?}"
+        show_model_details(model_display_name(model_spec))
+        puts
+      end
+    end
+
+    def show_model_details(model_name)
+      model_info = RubyLLM::Models.find(model_name)
+      if model_info
+        puts "   Provider: #{model_info.provider || 'Unknown'}"
+        puts "   Context window: #{model_info.context_window || 'Unknown'}"
+        puts "   Input cost: $#{model_info.input_cost || 'Unknown'}"
+        puts "   Output cost: $#{model_info.output_cost || 'Unknown'}"
+        puts "   Mode: #{model_info.modalities || 'Unknown'}"
+        puts "   Capabilities: #{(model_info.capabilities || []).join(', ')}" if model_info.capabilities&.any?
+      else
+        puts "   Details: Model not found in registry"
+      end
+    rescue StandardError => e
+      puts "   Details: Unable to fetch (#{e.class.name}: #{e.message})"
+    end
+
+    # 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.
+    # :reek:TooManyStatements -- three key-addressing forms (dot-notation walk, CLI map, direct setter) tried in order
+    def write_config_value(config_item, new_value) # rubocop:disable Naming/PredicateMethod
+      key_str = config_item.to_s
+      cfg     = AIA.config
+
+      # Dot-notation: walk the config object by path segments
+      if key_str.include?('.')
+        parts   = key_str.split('.')
+        obj     = cfg
+        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) &&
+         cfg.respond_to?(:apply_overrides)
+        cfg.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 cfg.respond_to?("#{key_str}=")
+        cfg.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
+
+      cfg = AIA.config
+      return unless cfg.respond_to?(:log_level_override=)
+
+      cfg.log_level_override = nil if cfg.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
@@ -19,6 +21,7 @@ module AIA
     end
 
     desc "Create a named checkpoint of the current context"
+    # :reek:TooManyStatements -- one snapshot build: name resolution, deep copy of every chat message list, store entry, feedback
     def checkpoint(args, _unused = nil)
       name = args.empty? ? nil : args.join(' ').strip
 
@@ -32,9 +35,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,10 +47,11 @@ 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"
+    # :reek:TooManyStatements -- restore flow: name resolution, validation, per-chat message replacement, user feedback
     def restore(args, _unused = nil)
       name = args.empty? ? nil : args.join(' ').strip
 
@@ -64,16 +68,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 +86,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 +94,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
@@ -115,39 +113,20 @@ module AIA
       chats = get_chats
       return "Error: No active chat sessions found." if chats.nil? || chats.empty?
 
-      first_chat = chats.values.first
-      messages = first_chat&.messages || []
-
-      puts "\n=== Chat Context (RubyLLM) ==="
-      puts "Total messages: #{messages.size}"
-      puts "Models: #{chats.keys.join(', ')}"
-      puts "Checkpoints: #{checkpoint_names.join(', ')}" if checkpoint_names.any?
-      puts
+      messages = chats.values.first&.messages || []
+      print_review_header(chats, messages.size)
 
       positions = checkpoint_positions
-
       messages.each_with_index do |msg, index|
-        if positions[index]
-          puts "📍 [Checkpoint: #{positions[index].join(', ')}]"
-          puts "-" * 40
-        end
-
-        role = msg.role.to_s.capitalize
-        content = format_message_content(msg)
-
-        puts "#{index + 1}. [#{role}]: #{content}"
-        puts
-      end
-
-      if positions[messages.size]
-        puts "📍 [Checkpoint: #{positions[messages.size].join(', ')}]"
-        puts "-" * 40
+        print_checkpoint_marker(positions[index])
+        print_review_message(msg, index)
       end
+      print_checkpoint_marker(positions[messages.size])
 
       puts "=== End of Context ==="
       ""
     end
-    alias_method :context, :review
+    alias context review
 
     desc "List all available checkpoints"
     def checkpoints_list(args, _unused = nil)
@@ -159,15 +138,16 @@ module AIA
       puts "\n=== Available Checkpoints ==="
       @checkpoint_store.each do |name, data|
         created = data[:created_at]&.strftime('%H:%M:%S') || 'unknown'
+        preview = data[:topic_preview]
         puts "  #{name}: position #{data[:position]}, created #{created}"
-        if data[:topic_preview] && !data[:topic_preview].empty?
-          puts "    → \"#{data[:topic_preview]}\""
+        if preview && !preview.empty?
+          puts "    → \"#{preview}\""
         end
       end
       puts "=== End of Checkpoints ==="
       ""
     end
-    alias_method :checkpoints, :checkpoints_list
+    alias checkpoints checkpoints_list
 
     # --- helpers (no desc → not registered as directives) ---
 
@@ -175,6 +155,27 @@ module AIA
       @checkpoint_store.keys
     end
 
+    def print_review_header(chats, total)
+      puts "\n=== Chat Context (RubyLLM) ==="
+      puts "Total messages: #{total}"
+      puts "Models: #{chats.keys.join(', ')}"
+      puts "Checkpoints: #{checkpoint_names.join(', ')}" if checkpoint_names.any?
+      puts
+    end
+
+    # Print the marker block when checkpoint names exist at this position.
+    def print_checkpoint_marker(names)
+      return unless names
+
+      puts "📍 [Checkpoint: #{names.join(', ')}]"
+      puts "-" * 40
+    end
+
+    def print_review_message(msg, index)
+      puts "#{index + 1}. [#{msg.role.to_s.capitalize}]: #{format_message_content(msg)}"
+      puts
+    end
+
     def checkpoint_positions
       positions = {}
       @checkpoint_store.each do |name, data|
@@ -200,9 +201,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 +248,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