aia 0.9.23 → 0.9.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38ae30b2341fb1e96738601b0c7cac5459772217d005aa5e22f18ecde270e2e0
-  data.tar.gz: 34555fad44d99436b4171887c0804c88f88e6fdc572e8a2d05476f485b0b80c6
+  metadata.gz: f9592d9ea1bbbbdc04f92dc822cfbdae91c1e04084530583e50f6cdb8a90460d
+  data.tar.gz: 897e53ec02de0fcc46a0e5ddcf15ca13a462b7cc20e4f355950f5872e5b04f00
 SHA512:
-  metadata.gz: 67182004edf9443ad3fc9190c1d57daa18c8f997d0425fa642e6f4c0c94d74490a1943ae1f79e7b18f55f65c0237a8fba31e765b750c374c8885926cbc08ca62
-  data.tar.gz: 3a86c4b7734a955180e7282a5462f7cda7ff83d1eac49c7106e63a69eaf9554a318ef2195ef61c4a61aec2340be6fdac8d19fd0d6a681f450e6c6c55b7c02940
+  metadata.gz: 5e8b63a8ca892346e4dd1090ef487e4fc6dc6b9395238ecc6208128d8908a5dca87d730a9193a15b05dbb005b8d9eb84e2bb7f63100982130eeec69e0bb9483d
+  data.tar.gz: 660c1c40117300223a7bd88c67ec826225a44ada72d459ee6c8fd3e3c015e81a7874a9618220c4dc7caf3de930ee140d29ef1c7c8dfc205ecfeedef8e629b36a

data/.version

@@ -1 +1 @@
-0.9.23
+0.9.24

data/CHANGELOG.md

@@ -1,6 +1,17 @@
 # Changelog
 ## [Unreleased]
 
+## [0.9.24] 2025-12-17
+### Fixes
+- Ran into a problem with the `shared_tools` gem and the --require parameter of AIA which required changes to both gems.
+
+### Improvements
+- **`//tools` Directive Filter**: Added optional filter parameter to the `//tools` directive
+  - Filter tools by name substring (case-insensitive)
+  - Example: `//tools error` lists only tools with "error" in the name
+  - Shows "No tools match the filter: [filter]" when no matches found
+  - Header indicates when filtering is active: "Available Tools (filtered by 'filter')"
+
 ## [0.9.23] 2025-12-06
 
 ### New Features

data/README.md

@@ -351,7 +351,7 @@ Directives are special commands in prompt files that begin with `//` and provide
 | `//help` | Show available directives | `//help` |
 | `//model` | Show current model configuration | `//model` |
 | `//available_models` | List available models | `//available_models` |
-| `//tools` | Show a list of available tools and their description | `//tools` |
+| `//tools` | Show available tools (optional filter by name) | `//tools` or `//tools file` |
 | `//review` | Review current context with checkpoint markers | `//review` |
 
 Directives can also be used in the interactive chat sessions.
@@ -1058,6 +1058,13 @@ Available Tools:
 - htm_query: Execute a query against the HTM database
 - htm_insert: Insert a record into HTM
 ...
+
+# Filter tools by name (case-insensitive)
+> //tools github
+
+Available Tools (filtered by 'github')
+- github_create_issue: Create a new GitHub issue
+- github_list_repos: List repositories for the authenticated user
 ```
 
 #### Troubleshooting MCP Servers

data/docs/directives-reference.md

@@ -214,11 +214,21 @@ Speak text using system text-to-speech (macOS/Linux).
 ## Utility Directives
 
 ### `//tools`
-Display available RubyLLM tools.
+Display available RubyLLM tools with optional filtering.
 
-**Syntax**: `//tools`
+**Syntax**: `//tools [filter]`
 
-**Example Output**:
+**Parameters**:
+- `filter` (optional) - Case-insensitive substring to filter tool names
+
+**Examples**:
+```markdown
+//tools           # List all available tools
+//tools file      # List tools with "file" in the name
+//tools analyzer  # List tools with "analyzer" in the name
+```
+
+**Example Output** (unfiltered):
 ```
 Available Tools
 ===============
@@ -234,6 +244,21 @@ WebScraper
     selectors and filters.
 ```
 
+**Example Output** (filtered with `//tools file`):
+```
+Available Tools (filtered by 'file')
+====================================
+
+FileReader
+----------
+    Read and analyze file contents with support for multiple formats
+    including text, JSON, YAML, and CSV files.
+```
+
+**Notes**:
+- When no tools match the filter, displays "No tools match the filter: [filter]"
+- Filtering is case-insensitive (e.g., "File", "FILE", and "file" all match)
+
 ### `//next`
 Set the next prompt to execute in a workflow.
 
@@ -509,11 +534,6 @@ SyntaxError: unexpected token
 ERROR: PUREMD_API_KEY is required in order to include a webpage
 ```
 
-**Missing Context Manager**:
-```
-Error: Context manager not available for //clear directive.
-```
-
 ### Custom Directives
 
 You can extend AIA with custom directives by creating Ruby files that define new directive methods:

data/docs/index.md

@@ -126,13 +126,13 @@ graph TD
 - **AIA::PromptHandler** - Main prompt processing orchestrator
 - **AIA::ChatProcessorService** - Interactive chat session management
 - **AIA::DirectiveProcessor** - Processes embedded directives (`//command params`)
-- **AIA::ContextManager** - Manages conversation context and history
-- **AIA::RubyLLMAdapter** - Interfaces with the ruby_llm gem for AI model communication
+- **AIA::RubyLLMAdapter** - Interfaces with the ruby_llm gem for AI model communication (manages conversation history via RubyLLM's Chat.@messages)
 - **AIA::ShellCommandExecutor** - Executes shell commands safely within prompts
 - **AIA::HistoryManager** - Manages prompt parameter history and user input
 - **AIA::UIPresenter** - Terminal output formatting and presentation
 - **AIA::Session** - Manages chat sessions and state
 - **AIA::Fzf** - Fuzzy finder integration for prompt selection
+- **AIA::Directives::Checkpoint** - Manages conversation checkpoints, restore, clear, and review operations
 
 ### External Dependencies
 

data/lib/aia/config/base.rb

@@ -157,6 +157,9 @@ module AIA
           config.require_libs.each do |library|
             begin
               require(library)
+              # Check if the library provides tools that need eager loading
+              # Convert library name to module constant (e.g., 'shared_tools' -> 'SharedTools')
+              eager_load_tools_from_library(library)
             rescue => e
               STDERR.puts "Error loading library '#{library}' #{e.message}"
             exit_on_error = true
@@ -168,6 +171,23 @@ module AIA
           config
         end
 
+        # Attempt to eager load tools from a required library
+        # Libraries that use Zeitwerk need their tools eager loaded so they
+        # appear in ObjectSpace for AIA's tool discovery
+        def eager_load_tools_from_library(library)
+          # Convert library name to module constant (e.g., 'shared_tools' -> 'SharedTools')
+          module_name = library.split('/').first.split('_').map(&:capitalize).join
+
+          begin
+            mod = Object.const_get(module_name)
+            if mod.respond_to?(:load_all_tools)
+              mod.load_all_tools
+            end
+          rescue NameError
+            # Module doesn't exist with expected name, skip
+          end
+        end
+
         def load_tools(config)
           return if config.tool_paths.empty?
 

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

@@ -88,100 +88,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

@@ -231,9 +231,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 +262,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 +284,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 +321,7 @@ module AIA
             'temperature' => ['temp'],
             'top_p' => ['topp'],
             'review' => ['context'],
-            'checkpoint' => ['cp'],
+            'checkpoint' => ['ckp', 'cp'],
             'pipeline' => ['workflow'],
             'ruby' => ['rb'],
             'shell' => ['sh'],
@@ -333,7 +340,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,34 @@ module AIA
           indent = 4
           spaces = " " * indent
           width = TTY::Screen.width - indent - 2
+          filter = args.first&.downcase
 
           if AIA.config.tools.empty?
             puts "No tools are available"
           else
-            puts
-            puts "Available Tools"
-            puts "==============="
+            tools_to_display = AIA.config.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

data/lib/aia/ruby_llm_adapter.rb

@@ -5,7 +5,7 @@ require_relative '../extensions/ruby_llm/provider_fix'
 
 module AIA
   class RubyLLMAdapter
-    attr_reader :tools, :model_specs
+    attr_reader :tools, :model_specs, :chats
 
     def initialize
       @model_specs = extract_models_config  # Full specs with role info
@@ -228,7 +228,17 @@ module AIA
 
     def support_local_tools
       @tools += ObjectSpace.each_object(Class).select do |klass|
-        klass < RubyLLM::Tool
+        next false unless klass < RubyLLM::Tool
+
+        # Filter out tools that can't be instantiated without arguments
+        # RubyLLM calls tool.new without args, so we must verify each tool works
+        begin
+          klass.new
+          true
+        rescue ArgumentError, LoadError, StandardError
+          # Skip tools that require arguments or have missing dependencies
+          false
+        end
       end
     end
 
@@ -634,7 +644,10 @@ module AIA
 
       @tools.select! do |tool|
         tool_name = tool.respond_to?(:name) ? tool.name : tool.class.name
-        AIA.config.allowed_tools.any? { |allowed| tool_name.include?(allowed) }
+        AIA.config.allowed_tools
+          .split(',')
+          .map(&:strip)
+          .any? { |allowed| tool_name.include?(allowed) }
       end
     end
 
@@ -644,7 +657,10 @@ module AIA
 
       @tools.reject! do |tool|
         tool_name = tool.respond_to?(:name) ? tool.name : tool.class.name
-        AIA.config.rejected_tools.any? { |rejected| tool_name.include?(rejected) }
+        AIA.config.rejected_tools
+          .split(',')
+          .map(&:strip)
+          .any? { |rejected| tool_name.include?(rejected) }
       end
     end
 

data/lib/aia/session.rb

@@ -9,7 +9,6 @@ require "fileutils"
 require "amazing_print"
 require_relative "directive_processor"
 require_relative "history_manager"
-require_relative "context_manager"
 require_relative "ui_presenter"
 require_relative "chat_processor_service"
 require_relative "prompt_handler"
@@ -45,28 +44,9 @@ module AIA
     end
 
     def initialize_components
-      # For multi-model: create separate context manager per model (ADR-002 revised + ADR-005)
-      # For single-model: maintain backward compatibility with single context manager
-      if AIA.config.model.is_a?(Array) && AIA.config.model.size > 1
-        @context_managers = {}
-        AIA.config.model.each do |model_spec|
-          # Handle both old string format and new hash format (ADR-005)
-          internal_id = if model_spec.is_a?(Hash)
-                          model_spec[:internal_id]
-                        else
-                          model_spec
-                        end
-
-          @context_managers[internal_id] = ContextManager.new(
-            system_prompt: AIA.config.system_prompt
-          )
-        end
-        @context_manager = nil # Signal we're using per-model managers
-      else
-        @context_manager = ContextManager.new(system_prompt: AIA.config.system_prompt)
-        @context_managers = nil
-      end
-
+      # RubyLLM's Chat instances maintain conversation history internally
+      # via @messages array. No separate context manager needed.
+      # Checkpoint/restore directives access Chat.@messages directly via AIA.client.chats
       @ui_presenter = UIPresenter.new
       @directive_processor = DirectiveProcessor.new
       @chat_processor = ChatProcessorService.new(@ui_presenter, @directive_processor)
@@ -225,23 +205,21 @@ module AIA
     end
 
     # Send prompt to AI and handle the response
+    # RubyLLM's Chat automatically adds user messages and responses to its internal @messages
     def send_prompt_and_get_response(prompt_text)
-      # Add prompt to conversation context
-      @context_manager.add_to_context(role: "user", content: prompt_text)
-
-      # Process the prompt
+      # Process the prompt - RubyLLM Chat maintains conversation history internally
       @ui_presenter.display_thinking_animation
-      response = @chat_processor.process_prompt(@context_manager.get_context)
+      response_data = @chat_processor.process_prompt(prompt_text)
 
-      # Add AI response to context
-      @context_manager.add_to_context(role: "assistant", content: response)
+      # Handle response format (may include metrics)
+      content = response_data.is_a?(Hash) ? response_data[:content] : response_data
 
       # Output the response
-      @chat_processor.output_response(response)
+      @chat_processor.output_response(content)
 
       # Process any directives in the response
-      if @directive_processor.directive?(response)
-        directive_result = @directive_processor.process(response, @context_manager)
+      if @directive_processor.directive?(content)
+        directive_result = @directive_processor.process(content, nil)
         puts "\nDirective output: #{directive_result}" if directive_result && !directive_result.strip.empty?
       end
     end
@@ -315,19 +293,16 @@ module AIA
 
       return if context.empty?
 
-      # Add context files content to context
-      @context_manager.add_to_context(role: "user", content: context)
-
-      # Process the context
+      # Process the context - RubyLLM Chat maintains conversation history internally
       @ui_presenter.display_thinking_animation
-      response = @chat_processor.process_prompt(@context_manager.get_context)
+      response_data = @chat_processor.process_prompt(context)
 
-      # Add AI response to context
-      @context_manager.add_to_context(role: "assistant", content: response)
+      # Handle response format (may include metrics)
+      content = response_data.is_a?(Hash) ? response_data[:content] : response_data
 
       # Output the response
-      @chat_processor.output_response(response)
-      @chat_processor.speak(response)
+      @chat_processor.output_response(content)
+      @chat_processor.speak(content)
       @ui_presenter.display_separator
     end
 
@@ -347,14 +322,15 @@ module AIA
         @chat_prompt.text = piped_input
         processed_input = @chat_prompt.to_s
 
-        @context_manager.add_to_context(role: "user", content: processed_input)
-
+        # Process the piped input - RubyLLM Chat maintains conversation history internally
         @ui_presenter.display_thinking_animation
-        response = @chat_processor.process_prompt(@context_manager.get_context)
+        response_data = @chat_processor.process_prompt(processed_input)
+
+        # Handle response format (may include metrics)
+        content = response_data.is_a?(Hash) ? response_data[:content] : response_data
 
-        @context_manager.add_to_context(role: "assistant", content: response)
-        @chat_processor.output_response(response)
-        @chat_processor.speak(response) if AIA.speak?
+        @chat_processor.output_response(content)
+        @chat_processor.speak(content) if AIA.speak?
         @ui_presenter.display_separator
 
         STDIN.reopen(original_stdin)
@@ -389,29 +365,10 @@ module AIA
         @chat_prompt.text = follow_up_prompt
         processed_prompt = @chat_prompt.to_s
 
-        # Handle per-model contexts (ADR-002 revised)
-        if @context_managers
-          # Multi-model: add user prompt to each model's context
-          @context_managers.each_value do |ctx_mgr|
-            ctx_mgr.add_to_context(role: "user", content: processed_prompt)
-          end
-
-          # Get per-model conversations
-          conversations = {}
-          @context_managers.each do |model_name, ctx_mgr|
-            conversations[model_name] = ctx_mgr.get_context
-          end
-
-          @ui_presenter.display_thinking_animation
-          response_data = @chat_processor.process_prompt(conversations)
-        else
-          # Single-model: use original logic
-          @context_manager.add_to_context(role: "user", content: processed_prompt)
-          conversation = @context_manager.get_context
-
-          @ui_presenter.display_thinking_animation
-          response_data = @chat_processor.process_prompt(conversation)
-        end
+        # Process the prompt - RubyLLM Chat maintains conversation history internally
+        # via @messages array. Each model's Chat instance tracks its own conversation.
+        @ui_presenter.display_thinking_animation
+        response_data = @chat_processor.process_prompt(processed_prompt)
 
         # Handle new response format with metrics
         if response_data.is_a?(Hash)
@@ -437,21 +394,6 @@ module AIA
           end
         end
 
-        # Add responses to context (ADR-002 revised)
-        if @context_managers
-          # Multi-model: parse combined response and add each model's response to its own context
-          parsed_responses = parse_multi_model_response(content)
-          parsed_responses.each do |model_name, model_response|
-            @context_managers[model_name]&.add_to_context(
-              role: "assistant",
-              content: model_response
-            )
-          end
-        else
-          # Single-model: add response to single context
-          @context_manager.add_to_context(role: "assistant", content: content)
-        end
-
         @chat_processor.speak(content)
 
         @ui_presenter.display_separator
@@ -459,71 +401,21 @@ module AIA
     end
 
     def process_chat_directive(follow_up_prompt)
-      # For multi-model, use first context manager for directives (ADR-002 revised)
-      # TODO: Consider if directives should affect all contexts or just one
-      context_for_directive = @context_managers ? @context_managers.values.first : @context_manager
-      directive_output = @directive_processor.process(follow_up_prompt, context_for_directive)
-
-      return handle_clear_directive if follow_up_prompt.strip.start_with?("//clear")
-      return handle_checkpoint_directive(directive_output) if follow_up_prompt.strip.start_with?("//checkpoint")
-      return handle_restore_directive(directive_output) if follow_up_prompt.strip.start_with?("//restore")
-      return handle_empty_directive_output if directive_output.nil? || directive_output.strip.empty?
-
-      handle_successful_directive(follow_up_prompt, directive_output)
-    end
-
-    def handle_clear_directive
-      # Clear context manager(s) - ADR-002 revised
-      if @context_managers
-        # Multi-model: clear all context managers
-        @context_managers.each_value { |ctx_mgr| ctx_mgr.clear_context(keep_system_prompt: true) }
-      else
-        # Single-model: clear single context manager
-        @context_manager.clear_context(keep_system_prompt: true)
-      end
-
-      # Try clearing the client's context
-      if AIA.config.client && AIA.config.client.respond_to?(:clear_context)
-        begin
-          AIA.config.client.clear_context
-        rescue => e
-          STDERR.puts "Warning: Error clearing client context: #{e.message}"
-          # Continue anyway - the context manager has been cleared which is the main goal
-        end
+      # Directives now access RubyLLM's Chat.@messages directly via AIA.client
+      # The second parameter is no longer used by checkpoint/restore/clear/review
+      directive_output = @directive_processor.process(follow_up_prompt, nil)
+
+      # Checkpoint-related directives (clear, checkpoint, restore, review) handle
+      # everything internally via the Checkpoint module, which operates directly
+      # on RubyLLM's Chat.@messages - no additional handling needed here.
+      if follow_up_prompt.strip.start_with?("//clear", "//checkpoint", "//restore", "//review", "//context")
+        @ui_presenter.display_info(directive_output) unless directive_output.nil? || directive_output.strip.empty?
+        return nil
       end
 
-      # Note: We intentionally do NOT reinitialize the client here
-      # as that could cause termination if model initialization fails
-
-      @ui_presenter.display_info("Chat context cleared.")
-      nil
-    end
-
-    def handle_checkpoint_directive(directive_output)
-      @ui_presenter.display_info(directive_output)
-      nil
-    end
-
-    def handle_restore_directive(directive_output)
-      # If the restore was successful, we also need to refresh the client's context - ADR-002 revised
-      if directive_output.start_with?("Context restored")
-        # Clear the client's context without reinitializing the entire adapter
-        if AIA.config.client && AIA.config.client.respond_to?(:clear_context)
-          begin
-            AIA.config.client.clear_context
-          rescue => e
-            STDERR.puts "Warning: Error clearing client context after restore: #{e.message}"
-            # Continue anyway - the context manager has been restored which is the main goal
-          end
-        end
-
-        # Note: For multi-model, only the first context manager was used for restore
-        # This is a limitation of the current directive system
-        # TODO: Consider supporting restore for all context managers
-      end
+      return handle_empty_directive_output if directive_output.nil? || directive_output.strip.empty?
 
-      @ui_presenter.display_info(directive_output)
-      nil
+      handle_successful_directive(follow_up_prompt, directive_output)
     end
 
     def handle_empty_directive_output

data/lib/aia/topic_context.rb

@@ -0,0 +1,125 @@
+# lib/aia/topic_context.rb
+# Just thinking about the problem ...
+# maybe a directive like //topic [topic]
+# sets manually (when present) or dynamically when not present
+# and //topics - will list current topics
+# thinking about the //checkpoint and //restore directives
+#
+module AIA
+  class TopicContext
+    attr_reader :context_size
+
+    # Initialize topic context manager
+    # @param context_size [Integer] max allowed bytes per topic
+    def initialize(context_size = 128_000)
+      @storage = Hash.new { |h, k| h[k] = [] } # auto-initialize empty array
+      @context_size = context_size
+      @total_chars = 0
+      @mutex = Mutex.new # ensure thread safety
+    end
+
+    # Store a request/response pair under the given topic (or auto-generate one)
+    # @param request [String]
+    # @param response [String]
+    # @param topic [String, nil]
+    # @return [String] topic name used
+    def store_conversation(request, response, topic = nil)
+      raise ArgumentError, "request and response must be strings" unless request.is_a?(String) && response.is_a?(String)
+
+      topic ||= generate_topic(request)
+      size = request.bytesize + response.bytesize
+
+      @mutex.synchronize do
+        # Add the new context
+        @storage[topic] << { request:, response:, size:, time: Time.now }
+
+        # Update the global total
+        @total_chars += size
+
+        # Trim old entries if we exceeded the per-topic limit
+        trim_topic(topic)
+      end
+
+      topic
+    end
+
+    # Return an array of contexts for the given topic
+    # @param topic [String]
+    # @return [Array<Hash>]
+    def get_conversation(topic)
+      @mutex.synchronize { @storage[topic] || [] }
+    end
+
+    # All topic names
+    # @return [Array<String>]
+    def topics
+      @mutex.synchronize { @storage.keys }
+    end
+
+    # Hash of topic => array_of_contexts
+    # @return [Hash<String, Array<Hash>>]
+    def all_conversations
+      @mutex.synchronize { @storage.dup }
+    end
+
+    # Total number of characters stored across all topics
+    # @return [Integer]
+    def total_chars
+      @mutex.synchronize { @total_chars }
+    end
+
+    # Empty the storage and reset counters
+    def clear
+      @mutex.synchronize do
+        @storage.clear
+        @total_chars = 0
+      end
+    end
+
+    # Get memory usage statistics for a topic
+    # @param topic [String]
+    # @return [Hash{Symbol => Integer}]
+    def topic_stats(topic)
+      @mutex.synchronize do
+        return {} unless @storage.key?(topic)
+
+        {
+          count: @storage[topic].length,
+          size: topic_total_size(topic),
+          avg_size: topic_total_size(topic).fdiv(@storage[topic].length),
+        }
+      end
+    end
+
+    private
+
+    # Topic extractor with better heuristic - uses first meaningful 3 words
+    # @param request [String]
+    # @return [String]
+    def generate_topic(request)
+      cleaned = request.downcase.gsub(/[^a-z0-9\s]/, "")
+      words = cleaned.split
+      return "general" if words.empty?
+
+      words.first(3).join("_")
+    end
+
+    # Remove oldest contexts from the topic until size <= @context_size
+    # @param topic [String]
+    def trim_topic(topic)
+      return unless @storage.key?(topic) && @storage[topic].size > 1
+
+      while topic_total_size(topic) > @context_size
+        removed = @storage[topic].shift # oldest context
+        @total_chars -= removed[:size]  # adjust global counter
+      end
+    end
+
+    # Helper to compute the sum of sizes for a topic
+    # @param topic [String]
+    # @return [Integer]
+    def topic_total_size(topic)
+      @storage[topic].sum { |ctx| ctx[:size] }
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aia
 version: !ruby/object:Gem::Version
-  version: 0.9.23
+  version: 0.9.24
 platform: ruby
 authors:
 - Dewayne VanHoozer
@@ -426,8 +426,8 @@ files:
 - lib/aia/config/defaults.rb
 - lib/aia/config/file_loader.rb
 - lib/aia/config/validator.rb
-- lib/aia/context_manager.rb
 - lib/aia/directive_processor.rb
+- lib/aia/directives/checkpoint.rb
 - lib/aia/directives/configuration.rb
 - lib/aia/directives/execution.rb
 - lib/aia/directives/models.rb
@@ -439,6 +439,7 @@ files:
 - lib/aia/prompt_handler.rb
 - lib/aia/ruby_llm_adapter.rb
 - lib/aia/session.rb
+- lib/aia/topic_context.rb
 - lib/aia/ui_presenter.rb
 - lib/aia/utility.rb
 - lib/aia/version.rb
@@ -477,7 +478,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.0
+rubygems_version: 4.0.1
 specification_version: 4
 summary: Multi-model AI CLI with dynamic prompts, consensus responses, shell & Ruby
   integration, and seamless chat workflows.

data/lib/aia/context_manager.rb

@@ -1,134 +0,0 @@
-# lib/aia/context_manager.rb
-
-module AIA
-  # Manages the conversation context for chat sessions.
-  class ContextManager
-    attr_reader :context, :checkpoints
-
-    # Initializes the ContextManager with an optional system prompt.
-    def initialize(system_prompt: nil)
-      @context = []
-      @checkpoints = {}
-      @checkpoint_counter = 0
-      add_system_prompt(system_prompt) if system_prompt && !system_prompt.strip.empty?
-    end
-
-    # Adds a message to the conversation context.
-    #
-    # @param role [String] The role of the message sender ('user' or 'assistant').
-    # @param content [String] The content of the message.
-    def add_to_context(role:, content:)
-      @context << { role: role, content: content }
-    end
-
-    # Returns the current conversation context.
-    # Optionally adds the system prompt if it wasn't added during initialization
-    # or needs to be re-added after clearing.
-    #
-    # @param system_prompt [String, nil] The system prompt to potentially prepend.
-    # @return [Array<Hash>] The conversation context array.
-    def get_context(system_prompt: nil)
-      # Add or replace system prompt if provided and not empty
-      if system_prompt && !system_prompt.strip.empty?
-        add_system_prompt(system_prompt)
-      end
-      @context
-    end
-
-    # Clears the conversation context, optionally keeping the system prompt.
-    #
-    # @param keep_system_prompt [Boolean] Whether to retain the initial system prompt.
-    def clear_context(keep_system_prompt: true)
-      if keep_system_prompt && !@context.empty? && @context.first[:role] == 'system'
-        @context = [@context.first]
-      else
-        @context = []
-      end
-
-      # Clear all checkpoints when clearing context
-      @checkpoints.clear
-      @checkpoint_counter = 0
-
-      # Attempt to clear the LLM client's context as well
-      begin
-        if AIA.config.client && AIA.config.client.respond_to?(:clear_context)
-          AIA.config.client.clear_context
-        end
-
-        if AIA.config.respond_to?(:llm) && AIA.config.llm && AIA.config.llm.respond_to?(:clear_context)
-          AIA.config.llm.clear_context
-        end
-
-        if defined?(RubyLLM) && RubyLLM.respond_to?(:chat) && RubyLLM.chat.respond_to?(:clear_history)
-          RubyLLM.chat.clear_history
-        end
-      rescue => e
-        STDERR.puts "ERROR: context_manager clear_context error #{e.message}"
-      end
-    end
-
-    # Creates a checkpoint of the current context with an optional name.
-    #
-    # @param name [String, nil] The name of the checkpoint. If nil, uses an incrementing integer.
-    # @return [String] The name of the created checkpoint.
-    def create_checkpoint(name: nil)
-      if name.nil?
-        @checkpoint_counter += 1
-        name = @checkpoint_counter.to_s
-      end
-
-      # Store a deep copy of the current context and its position
-      @checkpoints[name] = {
-        context: @context.map(&:dup),
-        position: @context.size
-      }
-      @last_checkpoint_name = name
-      name
-    end
-
-    # Restores the context to a previously saved checkpoint.
-    #
-    # @param name [String, nil] The name of the checkpoint to restore. If nil, uses the last checkpoint.
-    # @return [Boolean] True if restore was successful, false otherwise.
-    def restore_checkpoint(name: nil)
-      name = @last_checkpoint_name if name.nil?
-
-      return false if name.nil? || !@checkpoints.key?(name)
-
-      # Restore the context from the checkpoint
-      checkpoint_data = @checkpoints[name]
-      @context = checkpoint_data[:context].map(&:dup)
-      true
-    end
-
-    # Returns the list of available checkpoint names.
-    #
-    # @return [Array<String>] The names of all checkpoints.
-    def checkpoint_names
-      @checkpoints.keys
-    end
-
-    # Returns checkpoint information mapped to context positions.
-    #
-    # @return [Hash<Integer, Array<String>>] Position to checkpoint names mapping.
-    def checkpoint_positions
-      positions = {}
-      @checkpoints.each do |name, data|
-        position = data[:position]
-        positions[position] ||= []
-        positions[position] << name
-      end
-      positions
-    end
-
-    private
-
-    # Adds or replaces the system prompt at the beginning of the context.
-    def add_system_prompt(system_prompt)
-       # Remove existing system prompt if present
-       @context.shift if !@context.empty? && @context.first[:role] == 'system'
-       # Add the new system prompt at the beginning
-       @context.unshift({ role: 'system', content: system_prompt })
-    end
-  end
-end