aia 0.9.23 → 0.10.2

data/lib/aia/directives/checkpoint.rb

@@ -0,0 +1,283 @@
+# lib/aia/directives/checkpoint.rb
+#
+# Checkpoint and restore directives for managing conversation state.
+# Uses RubyLLM's Chat.@messages as the source of truth for conversation history.
+#
+
+module AIA
+  module Directives
+    module Checkpoint
+      # Module-level state for checkpoints
+      # Note: Using @checkpoint_store to avoid naming conflict with //checkpoints directive
+      @checkpoint_store = {}
+      @checkpoint_counter = 0
+      @last_checkpoint_name = nil
+
+      class << self
+        attr_accessor :checkpoint_store, :checkpoint_counter, :last_checkpoint_name
+
+        # Reset all checkpoint state (useful for testing)
+        def reset!
+          @checkpoint_store = {}
+          @checkpoint_counter = 0
+          @last_checkpoint_name = nil
+        end
+      end
+
+      # //checkpoint [name]
+      # Creates a named checkpoint of the current conversation state.
+      # If no name is provided, uses an auto-incrementing number.
+      def self.checkpoint(args, _unused = nil)
+        name = args.empty? ? nil : args.join(' ').strip
+
+        if name.nil? || name.empty?
+          self.checkpoint_counter += 1
+          name = checkpoint_counter.to_s
+        end
+
+        chats = get_chats
+        return "Error: No active chat sessions found." if chats.nil? || chats.empty?
+
+        # Deep copy messages from all chats
+        first_chat_messages = chats.values.first&.messages || []
+        checkpoint_store[name] = {
+          messages: chats.transform_values { |chat|
+            chat.messages.map { |msg| deep_copy_message(msg) }
+          },
+          position: first_chat_messages.size,
+          created_at: Time.now,
+          topic_preview: extract_last_user_message(first_chat_messages)
+        }
+        self.last_checkpoint_name = name
+
+        puts "Checkpoint '#{name}' created at position #{checkpoint_store[name][:position]}."
+        ""
+      end
+
+      # //restore [name]
+      # Restores the conversation state to a previously saved checkpoint.
+      # If no name is provided, restores to the previous checkpoint (one step back).
+      def self.restore(args, _unused = nil)
+        name = args.empty? ? nil : args.join(' ').strip
+
+        if name.nil? || name.empty?
+          # Find the previous checkpoint (second-to-last by position)
+          name = find_previous_checkpoint
+          if name.nil?
+            return "Error: No previous checkpoint to restore to."
+          end
+        end
+
+        unless checkpoint_store.key?(name)
+          available = checkpoint_names.empty? ? "none" : checkpoint_names.join(', ')
+          return "Error: Checkpoint '#{name}' not found. Available: #{available}"
+        end
+
+        checkpoint_data = checkpoint_store[name]
+        chats = get_chats
+
+        return "Error: No active chat sessions found." if chats.nil? || chats.empty?
+
+        # Restore messages to each chat
+        checkpoint_data[:messages].each do |model_id, saved_messages|
+          chat = chats[model_id]
+          next unless chat
+
+          # Replace the chat's messages with the saved ones
+          restored_messages = saved_messages.map { |msg| deep_copy_message(msg) }
+          chat.instance_variable_set(:@messages, restored_messages)
+        end
+
+        # Remove checkpoints that are now invalid (position > restored position)
+        # because they reference conversation states that no longer exist
+        restored_position = checkpoint_data[:position]
+        removed_count = remove_invalid_checkpoints(restored_position)
+
+        # Update last_checkpoint_name to this checkpoint
+        self.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
+      end
+
+      # //clear
+      # Clears the conversation context, optionally keeping the system prompt.
+      def self.clear(args, _unused = nil)
+        keep_system = !args.include?('--all')
+
+        chats = get_chats
+        return "Error: No active chat sessions found." if chats.nil? || chats.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
+        end
+
+        # Clear all checkpoints
+        checkpoint_store.clear
+        self.checkpoint_counter = 0
+        self.last_checkpoint_name = nil
+
+        "Chat context cleared."
+      end
+
+      # //review
+      # Displays the current conversation context with checkpoint markers.
+      def self.review(args, _unused = nil)
+        chats = get_chats
+        return "Error: No active chat sessions found." if chats.nil? || chats.empty?
+
+        # For multi-model, show first chat's messages (they should be similar for user messages)
+        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
+
+        positions = checkpoint_positions
+
+        messages.each_with_index do |msg, index|
+          # Show checkpoint marker if one exists at this position
+          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
+
+        # Check for checkpoint at the end
+        if positions[messages.size]
+          puts "📍 [Checkpoint: #{positions[messages.size].join(', ')}]"
+          puts "-" * 40
+        end
+
+        puts "=== End of Context ==="
+        ""
+      end
+
+      # //checkpoints
+      # Lists all available checkpoints with their details.
+      def self.checkpoints_list(args, _unused = nil)
+        if checkpoint_store.empty?
+          puts "No checkpoints available."
+          return ""
+        end
+
+        puts "\n=== Available Checkpoints ==="
+        checkpoint_store.each do |name, data|
+          created = data[:created_at]&.strftime('%H:%M:%S') || 'unknown'
+          puts "  #{name}: position #{data[:position]}, created #{created}"
+          if data[:topic_preview] && !data[:topic_preview].empty?
+            puts "    → \"#{data[:topic_preview]}\""
+          end
+        end
+        puts "=== End of Checkpoints ==="
+        ""
+      end
+
+      # Helper methods
+      def self.checkpoint_names
+        checkpoint_store.keys
+      end
+
+      def self.checkpoint_positions
+        positions = {}
+        checkpoint_store.each do |name, data|
+          pos = data[:position]
+          positions[pos] ||= []
+          positions[pos] << name
+        end
+        positions
+      end
+
+      # Remove checkpoints with position > the given position
+      # Returns the count of removed checkpoints
+      def self.remove_invalid_checkpoints(max_position)
+        invalid_names = checkpoint_store.select { |_name, data| data[:position] > max_position }.keys
+        invalid_names.each { |name| checkpoint_store.delete(name) }
+        invalid_names.size
+      end
+
+      # Find the previous checkpoint (second-to-last by position)
+      # This is used when //restore is called without a name
+      def self.find_previous_checkpoint
+        return nil if checkpoint_store.size < 2
+
+        # Sort checkpoints by position descending, return the second one
+        sorted = checkpoint_store.sort_by { |_name, data| -data[:position] }
+        sorted[1]&.first  # Return the name of the second-to-last checkpoint
+      end
+
+      private
+
+      def self.get_chats
+        return nil unless AIA.client.respond_to?(:chats)
+
+        AIA.client.chats
+      end
+
+      def self.deep_copy_message(msg)
+        RubyLLM::Message.new(
+          role: msg.role,
+          content: msg.content,
+          tool_calls: msg.tool_calls&.transform_values { |tc| tc.dup rescue tc },
+          tool_call_id: msg.tool_call_id,
+          input_tokens: msg.input_tokens,
+          output_tokens: msg.output_tokens,
+          model_id: msg.model_id
+        )
+      end
+
+      def self.format_message_content(msg)
+        if msg.tool_call?
+          tool_names = msg.tool_calls.values.map(&:name).join(', ')
+          "[Tool calls: #{tool_names}]"
+        elsif msg.tool_result?
+          result_preview = msg.content.to_s[0..50]
+          "[Tool result for: #{msg.tool_call_id}] #{result_preview}..."
+        else
+          content = msg.content.to_s
+          content.length > 150 ? "#{content[0..147]}..." : content
+        end
+      end
+
+      # Extract a preview of the last user message for checkpoint context
+      def self.extract_last_user_message(messages, max_length: 70)
+        return "" if messages.nil? || messages.empty?
+
+        # Find the last user message (not system, not assistant, not tool)
+        last_user_msg = messages.reverse.find { |msg| msg.role == :user }
+        return "" unless last_user_msg
+
+        content = last_user_msg.content.to_s.strip
+        # Collapse whitespace and truncate
+        content = content.gsub(/\s+/, ' ')
+        content.length > max_length ? "#{content[0..max_length - 4]}..." : content
+      end
+
+      # Aliases
+      class << self
+        alias_method :ckp, :checkpoint
+        alias_method :cp, :checkpoint
+        alias_method :context, :review
+        # Route //checkpoints directive to checkpoints_list
+        # (safe now that we renamed attr_accessor to checkpoint_store)
+        alias_method :checkpoints, :checkpoints_list
+      end
+    end
+  end
+end

data/lib/aia/directives/configuration.rb

@@ -7,12 +7,17 @@ module AIA
           args = Array(args)
 
           if args.empty?
-            ap AIA.config
+            ap AIA.config.to_h
             ""
           elsif args.length == 1
             config_item = args.first
-            local_cfg = Hash.new
-            local_cfg[config_item] = AIA.config[config_item]
+            local_cfg = {}
+            # Use method-based access for Anyway::Config
+            if AIA.config.respond_to?(config_item)
+              local_cfg[config_item] = AIA.config.send(config_item)
+            else
+              local_cfg[config_item] = nil
+            end
             ap local_cfg
             ""
           else
@@ -24,7 +29,13 @@ module AIA
               new_value = %w[true t yes y on 1 yea yeah yep yup].include?(new_value.downcase)
             end
 
-            AIA.config[config_item] = new_value
+            # Use method-based setter for Anyway::Config
+            setter = "#{config_item}="
+            if AIA.config.respond_to?(setter)
+              AIA.config.send(setter, new_value)
+            else
+              puts "Warning: Unknown config option '#{config_item}'"
+            end
             ""
           end
         end
@@ -33,29 +44,32 @@ module AIA
           if args.empty?
             # Display details for all configured models
             puts
-            models = Array(AIA.config.model)
+            models = AIA.config.models
 
             if models.size == 1
               puts "Current Model:"
               puts "=============="
-              puts AIA.config.client.model.to_h.pretty_inspect
+              puts AIA.client.model.to_h.pretty_inspect
             else
               puts "Multi-Model Configuration:"
               puts "=========================="
               puts "Model count: #{models.size}"
-              puts "Primary model: #{models.first} (used for consensus when --consensus flag is enabled)"
-              puts "Consensus mode: #{AIA.config.consensus.nil? ? 'auto-detect (disabled by default)' : AIA.config.consensus}"
+              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_name, index|
+              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)' : ''}"
 
                 # Try to get model details if available
                 begin
                   # Access the model details from RubyLLM's model registry
-                  model_info = RubyLLM::Models.find(name: 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'}"
@@ -88,100 +102,15 @@ module AIA
           send(:config, args.prepend('top_p'), context_manager)
         end
 
-      def self.clear(args, context_manager = nil)
-          if context_manager.nil?
-            return "Error: Context manager not available for //clear directive."
-          end
-
-          context_manager.clear_context
-          ''
-        end
-
-      def self.review(args, context_manager = nil)
-          return "Error: Context manager not available for //review directive." if context_manager.nil?
-
-          context = context_manager.get_context
-          checkpoint_positions = context_manager.checkpoint_positions
-
-          # Display context with checkpoint markers
-          puts "\n=== Chat Context ==="
-          puts "Total messages: #{context.size}"
-
-          if checkpoint_positions.any?
-            puts "Checkpoints: #{context_manager.checkpoint_names.join(', ')}"
-          end
-
-          puts "\n"
-
-          context.each_with_index do |message, index|
-            # Check if there's a checkpoint at this position
-            if checkpoint_positions[index]
-              checkpoint_names = checkpoint_positions[index].join(', ')
-              puts "📍 [Checkpoint: #{checkpoint_names}]"
-              puts "-" * 40
-            end
-
-            # Display the message
-            role_display = message[:role].capitalize
-            content_preview = message[:content].to_s
-
-            # Truncate long content for display
-            if content_preview.length > 200
-              content_preview = content_preview[0..197] + "..."
-            end
-
-            puts "#{index + 1}. [#{role_display}]: #{content_preview}"
-            puts ""
-          end
-
-          # Check if there's a checkpoint at the end (after all messages)
-          if checkpoint_positions[context.size]
-            checkpoint_names = checkpoint_positions[context.size].join(', ')
-            puts "📍 [Checkpoint: #{checkpoint_names}]"
-            puts "-" * 40
-          end
-
-          puts "=== End of Context ==="
-          ''
-        end
-
-      def self.checkpoint(args, context_manager = nil)
-          if context_manager.nil?
-            return "Error: Context manager not available for //checkpoint directive."
-          end
-
-          name = args.empty? ? nil : args.join(' ').strip
-          checkpoint_name = context_manager.create_checkpoint(name: name)
-          puts "Checkpoint '#{checkpoint_name}' created."
-          ""
-      end
-
-      def self.restore(args, context_manager = nil)
-          if context_manager.nil?
-            return "Error: Context manager not available for //restore directive."
-          end
-
-          name = args.empty? ? nil : args.join(' ').strip
-
-          if context_manager.restore_checkpoint(name: name)
-            restored_name = name || context_manager.checkpoint_names.last
-            "Context restored to checkpoint '#{restored_name}'."
-          else
-            if name
-              "Error: Checkpoint '#{name}' not found. Available checkpoints: #{context_manager.checkpoint_names.join(', ')}"
-            else
-              "Error: No checkpoints available to restore."
-            end
-          end
-        end
+      # NOTE: clear, review, checkpoint, and restore directives have been moved to
+      # lib/aia/directives/checkpoint.rb which uses RubyLLM's Chat.@messages
+      # as the source of truth for conversation history.
 
       # Set up aliases - these work on the module's singleton class
       class << self
         alias_method :cfg, :config
         alias_method :temp, :temperature
         alias_method :topp, :top_p
-        alias_method :context, :review
-        alias_method :ckp, :checkpoint
       end
     end
   end

data/lib/aia/directives/models.rb

@@ -31,12 +31,11 @@ module AIA
 
       def self.available_models(args = nil, context_manager = nil)
           # Check if we're using a local provider
-          current_models = AIA.config.model
-          current_models = [current_models] if current_models.is_a?(String)
+          current_models = AIA.config.models
 
-          # Extract model names (handles both String and Hash formats)
+          # Extract model names (handles ModelSpec objects)
           model_names = current_models.map do |m|
-            m.is_a?(Hash) ? m[:model] : m
+            m.respond_to?(:name) ? m.name : m.to_s
           end
 
           using_local_provider = model_names.any? { |m| m.start_with?('ollama/', 'lms/') }
@@ -231,9 +230,10 @@ module AIA
             'review' => 'Display the current conversation context with checkpoint markers',
             'checkpoint' => 'Create a named checkpoint of the current context',
             'restore' => 'Restore context to a previous checkpoint',
+            'checkpoints_list' => 'List all available checkpoints',
 
             # Utility directives
-            'tools' => 'List available tools',
+            'tools' => 'List available tools (optional filter by name substring)',
             'next' => 'Set the next prompt in the sequence',
             'pipeline' => 'Set or view the prompt workflow sequence',
             'terse' => 'Add instruction for concise responses',
@@ -261,6 +261,7 @@ module AIA
             'temp' => nil, # alias for temperature
             'topp' => nil, # alias for top_p
             'context' => nil, # alias for review
+            'ckp' => nil, # alias for checkpoint
             'cp' => nil, # alias for checkpoint
             'workflow' => nil, # alias for pipeline
             'rb' => nil, # alias for ruby
@@ -282,13 +283,18 @@ module AIA
             AIA::Directives::Utility,
             AIA::Directives::Configuration,
             AIA::Directives::Execution,
-            AIA::Directives::Models
+            AIA::Directives::Models,
+            AIA::Directives::Checkpoint
           ]
 
           all_directives = {}
           excluded_methods = ['run', 'initialize', 'private?', 'descriptions', 'aliases', 'build_aliases',
                              'desc', 'method_added', 'register_directive_module', 'process',
-                             'directive?', 'prefix_size']
+                             'directive?', 'prefix_size', 'reset!', 'checkpoint_names',
+                             'checkpoint_positions', 'get_chats', 'deep_copy_message',
+                             'format_message_content', 'checkpoints', 'checkpoint_counter',
+                             'last_checkpoint_name', 'checkpoints=', 'checkpoint_counter=',
+                             'last_checkpoint_name=']
 
           # Collect directives from all modules
           all_modules.each do |mod|
@@ -314,7 +320,7 @@ module AIA
             'temperature' => ['temp'],
             'top_p' => ['topp'],
             'review' => ['context'],
-            'checkpoint' => ['cp'],
+            'checkpoint' => ['ckp', 'cp'],
             'pipeline' => ['workflow'],
             'ruby' => ['rb'],
             'shell' => ['sh'],
@@ -333,7 +339,7 @@ module AIA
 
           # Sort and display directives by category
           categories = {
-            'Configuration' => ['config', 'model', 'temperature', 'top_p', 'clear', 'review', 'checkpoint', 'restore'],
+            'Configuration' => ['config', 'model', 'temperature', 'top_p', 'clear', 'review', 'checkpoint', 'restore', 'checkpoints_list'],
             'Utility' => ['tools', 'next', 'pipeline', 'terse', 'robot', 'help'],
             'Execution' => ['ruby', 'shell', 'say'],
             'Web & Files' => ['webpage', 'include'],

data/lib/aia/directives/registry.rb

@@ -5,6 +5,7 @@ require_relative 'utility'
 require_relative 'configuration'
 require_relative 'execution'
 require_relative 'models'
+require_relative 'checkpoint'
 
 module AIA
   module Directives
@@ -115,6 +116,7 @@ module AIA
       register_directive_module(Configuration)
       register_directive_module(Execution)
       register_directive_module(Models)
+      register_directive_module(Checkpoint)
     end
   end
 end

data/lib/aia/directives/utility.rb

@@ -12,19 +12,35 @@ module AIA
           indent = 4
           spaces = " " * indent
           width = TTY::Screen.width - indent - 2
+          filter = args.first&.downcase
 
-          if AIA.config.tools.empty?
+          loaded_tools = AIA.config.loaded_tools || []
+          if loaded_tools.empty?
             puts "No tools are available"
           else
-            puts
-            puts "Available Tools"
-            puts "==============="
+            tools_to_display = loaded_tools
 
-            AIA.config.tools.each do |tool|
-              name = tool.respond_to?(:name) ? tool.name : tool.class.name
-              puts "\n#{name}"
-              puts "-" * name.size
-              puts WordWrapper::MinimumRaggedness.new(width, tool.description).wrap.split("\n").map { |s| spaces + s + "\n" }.join
+            if filter
+              tools_to_display = tools_to_display.select do |tool|
+                name = tool.respond_to?(:name) ? tool.name : tool.class.name
+                name.downcase.include?(filter)
+              end
+            end
+
+            if tools_to_display.empty?
+              puts "No tools match the filter: #{args.first}"
+            else
+              puts
+              header = filter ? "Available Tools (filtered by '#{args.first}')" : "Available Tools"
+              puts header
+              puts "=" * header.length
+
+              tools_to_display.each do |tool|
+                name = tool.respond_to?(:name) ? tool.name : tool.class.name
+                puts "\n#{name}"
+                puts "-" * name.size
+                puts WordWrapper::MinimumRaggedness.new(width, tool.description).wrap.split("\n").map { |s| spaces + s + "\n" }.join
+              end
             end
           end
           puts