aia 0.9.0 → 0.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 489e116b8ebfbfed10c2cd0d699a4e37294719d39899e65d4fec6f226dadf36d
-  data.tar.gz: 35f9488983cd2944c8638d51aacd31ba606ee3d01fcada61673a47aaba3f7645
+  metadata.gz: 543eb535dae7c828b1dbd2a2dd981e566d27b1c5d8ad4c81d1fd21566015f175
+  data.tar.gz: 021bf728dd9082c9fa1aca73d72001e4ed512d2c7ddd23cff044d5d9447a8d2d
 SHA512:
-  metadata.gz: f4bb461ff9f7ac7c775cd72be754e1698cf057033f3ae6100d9ad7d1f348de96116af1f4a7271adf32b399147ad572f2c9bb198b27bbc7909f88548d4124f577
-  data.tar.gz: 3312f7ab73822ab0c315f0842bde82223d617b08bcc0b0734ff502c58494ef9c608433a9efcff1c7923a4fa89537eee4df35247d85fa96a34cc5f0b5b71177f8
+  metadata.gz: 5b108c87dc2c82c0c347efa2b084ce1274b412324c33c2450a8174a655dca3be9c14e34b83347b90a9a7c8817b0eadb90a17f81536234eb38b8d09377f4a3221
+  data.tar.gz: 43bbef3a40562333650251dde1ea5868b4cef29ed7b35c447429a75552899a6a73989ae87546320e8a51370675192f1d18d71c56eef8b98985beb863341f4869

data/.version

@@ -1 +1 @@
-0.9.0
+0.9.2

data/CHANGELOG.md

@@ -1,11 +1,21 @@
 # Changelog
 ## [Unreleased]
-### [0.9.0] WIP
-- Adding MCP Client suppot
-- removed the CLI options --erb and --shell but kept them in the config file with a default of true for both
-
 ## Released
 
+### [0.9.2] 2025-05-18
+- removing the MCP experiment
+- adding support for RubyLLM::Tool usage in place of the MCP stuff
+- updated prompt_manager to v0.5.4 which fixed shell integration problem
+
+### [0.9.1] 2025-05-16
+- rethink MCP approach in favor of just RubyLLM::Tool
+- fixed problem with //clear
+- fixed a problem with a priming prompt in a chat loop
+
+### [0.9.0] 2025-05-13
+- Adding experimental MCP Client suppot
+- removed the CLI options --erb and --shell but kept them in the config file with a default of true for both
+
 ### [0.8.6] 2025-04-23
 - Added a client adapter for the ruby_llm gem
 - Added the adapter config item and the --adapter option to select at runtime which client to use ai_client or ruby_llm

data/README.md

@@ -11,23 +11,14 @@
     [/______\]  /               * embedded directives * shell integration
    / \__AI__/ \/                * embedded Ruby       * history management
   /    /__\                     * interactive chat    * prompt workflows
- (\   /____\                    # Experimental support of MCP servers via ruby_llm extension
+ (\   /____\                    # supports RubyLLM::Tool integration
 ```
 
 AIA leverages the [prompt_manager gem](https://github.com/madbomber/prompt_manager) to manage prompts. It utilizes the [CLI tool fzf](https://github.com/junegunn/fzf) for prompt selection.
 
-**Most Recent Change**: Refer to the [Changelog](CHANGELOG.md)
-- Replaced `ai_client` with `ruby_llm` gem
-- Added --adapter w/default ruby_llm in case there is a need to consider something else
-- //include directive now supports web URLs
-- //webpage insert web URL content as markdown into context
-
 **Wiki**: [Checkout the AIA Wiki](https://github.com/MadBomber/aia/wiki)
 
-**Notable Recent Changes:**
-- **RubyLLM Integration:** AIA now uses the `ruby_llm` gem as a replacement to ai_client. The option `--adapter ruby_llm` is the default.  The `--adapter` option is there in case in the future an alternative to ruby_llm may be needed. I replacing my on gem ai_client with the ruby_llm gem? Because its better, newer, elegant and will easily support some of the new features I have planned for AIA.
-
-- **MCP Server Support:** AIA now supports Model Context Protocol (MCP) servers through an extension to the ruby_llm gem. This experimental feature allows AIA to interact with various external tools and services through MCP servers using the --mcp and --allowed_tools CLI options.
+**MCRubyLLM::Tool Support:** AIA now supports the integration of Tools for those models that support function callbacks.  See the --tools, --allowed_tools and --rejected_tools options.  Yes, functional callbacks provided for dynamic prompt just like the AIA directives so why have both?  Well, AIA is older that functional callbacks.  Directives or legacy but more than that not all models support functional callbacks.  That means the old directives capability, shell and erb integration are still viable ways to provided dynamic extra content to your prompts.
 
 <!-- Tocer[start]: Auto-generated, don't remove. -->
 
@@ -70,13 +61,15 @@ AIA leverages the [prompt_manager gem](https://github.com/madbomber/prompt_manag
   - [Development](#development)
   - [Contributing](#contributing)
   - [Roadmap](#roadmap)
-  - [Model Context Protocol (MCP) Support](#model-context-protocol-mcp-support)
-    - [What is MCP?](#what-is-mcp)
-    - [Using MCP Servers with AIA](#using-mcp-servers-with-aia)
-    - [Focusing on Specific Tools with --allowed_tools](#focusing-on-specific-tools-with---allowed_tools)
-    - [How It Works](#how-it-works)
-    - [Current Limitations](#current-limitations)
-    - [Sounds like directives](#sounds-like-directives)
+  - [RubyLLM::Tool Support](#rubyllmtool-support)
+    - [What Are RubyLLM Tools?](#what-are-rubyllm-tools)
+    - [How to Use Tools](#how-to-use-tools)
+      - [`--tools` Option](#--tools-option)
+    - [Filtering the tool paths](#filtering-the-tool-paths)
+      - [`--at`, `--allowed_tools` Option](#--at---allowed_tools-option)
+      - [`--rt`, `--rejected_tools` Option](#--rt---rejected_tools-option)
+    - [Creating Your Own Tools](#creating-your-own-tools)
+  - [MCP Supported](#mcp-supported)
   - [License](#license)
 
 <!-- Tocer[finish]: Auto-generated, don't remove. -->
@@ -104,7 +97,6 @@ The following table provides a comprehensive list of configuration options, thei
 | log_file             | -l, --log_file | ~/.prompts/_prompts.log  | AIA_LOG_FILE              |
 | markdown             | --md, --markdown | true                   | AIA_MARKDOWN              |
 | max_tokens           | --max_tokens | 2048                      | AIA_MAX_TOKENS            |
-| mcp_servers          | --mcp       | []                          | AIA_MCP_SERVERS           |
 | model                | -m, --model | gpt-4o-mini                 | AIA_MODEL                 |
 | next                 | -n, --next  | nil                         | AIA_NEXT                  |
 | out_file             | -o, --out_file | temp.md                  | AIA_OUT_FILE              |
@@ -124,8 +116,11 @@ The following table provides a comprehensive list of configuration options, thei
 | system_prompt        | --system_prompt |                         | AIA_SYSTEM_PROMPT         |
 | temperature          | -t, --temperature | 0.7                   | AIA_TEMPERATURE           |
 | terse                | --terse     | false                       | AIA_TERSE                 |
+| tool_paths           | --tools     | []                          | AIA_TOOL_PATHS            |
+| allowed_tools        | --at --allowed_tools  | nil               | AIA_ALLOWED_TOOLS         |
+| rejected_tools       | --rt --rejected_tools | nil               | AIA_REJECTED_TOOLS         |
 | top_p                | --top_p     | 1.0                         | AIA_TOP_P                 |
-| transcription_model  | --tm, --transcription_model | whisper-1    | AIA_TRANSCRIPTION_MODEL   |
+| transcription_model  | --tm, --transcription_model | whisper-1   | AIA_TRANSCRIPTION_MODEL   |
 | verbose              | -v, --verbose | false                     | AIA_VERBOSE               |
 | voice                | --voice     | alloy                       | AIA_VOICE                 |
 
@@ -679,56 +674,83 @@ I'm not happy with the way where some command line options for external command
 - continue integration of the ruby_llm gem
 - support for Model Context Protocol
 
-## Model Context Protocol (MCP) Support
+## RubyLLM::Tool Support
+
+AIA supports function calling capabilities through the `RubyLLM::Tool` framework, enabling LLMs to execute custom functions during a chat session.
+
+### What Are RubyLLM Tools?
 
-AIA now includes experimental support for Model Context Protocol (MCP) servers through an extension to the `ruby_llm` gem, which utilizes the `ruby-mcp-client` gem for communication with MCP servers.
+Tools (or functions) allow LLMs to perform actions beyond generating text, such as:
 
-### What is MCP?
+- Retrieving real-time information
+- Executing system commands
+- Accessing external APIs
+- Performing calculations
 
-Model Context Protocol (MCP) is a standardized way for AI models to interact with external tools and services. It allows AI assistants to perform actions beyond mere text generation, such as searching the web, accessing databases, or interacting with APIs.
+Check out the [examples/tools](examples/tools) directory which contains several ready-to-use tool implementations you can use as references.
 
-### Using MCP Servers with AIA
+### How to Use Tools
 
-To use MCP with AIA, you can specify one or more MCP servers using the `--mcp` CLI option:
+AIA provides three CLI options to manage function calling:
+
+#### `--tools` Option
+
+Specifies where to find tool implementations:
 
 ```bash
-aia --chat --mcp server1,server2
+# Load tools from multiple sources
+--tools /path/to/tools/directory,other/tools/dir,my_tool.rb
+
+# Or use multiple --tools flags
+--tools my_first_tool.rb --tools /tool_repo/tools
 ```
 
-This will connect your AIA session to the specified MCP servers, allowing the AI model to access tools provided by those servers.
+Each path can be:
 
-### Focusing on Specific Tools with --allowed_tools
+- A Ruby file implementing a `RubyLLM::Tool` subclass
+- A directory containing tool implementations (all Ruby files in that directory will be loaded)
 
-If you want to limit which MCP tools are available to the AI model during your session, you can use the `--allowed_tools` option:
+Supporting files for tools can be placed in the same directory or subdirectories.
+
+### Filtering the tool paths
+
+The --tools option must have exact relative or absolute paths to the tool files to be used by AIA for function callbacks.  If you are specifying directories you may find yourself needing filter the entire set of tools to either allow some or reject others based upon some indicator in their file name.  The following two options allow you to specify multiple sub-strings to match the tolls paths against.  For example you might be comparing one version of a tool against another.  Their filenames could have version prefixes like tool_v1.rb and tool_v2.rb  Using the allowed and rejected filters you can choose one of the other when using an entire directory full of tools.
+
+#### `--at`, `--allowed_tools` Option
+
+Filters which tools to make available when loading from directories:
 
 ```bash
-aia --chat --mcp server1 --allowed_tools tool1,tool2,tool3
+# Only allow tools with 'test' in their filename
+--tools my_tools_directory --allowed_tools test
 ```
 
-This restricts the AI model to only use the specified tools, which can be helpful for:
+This is useful when you have many tools but only want to use specific ones in a session.
 
-- Focusing the AI on a specific task
-- Preventing the use of unnecessary or potentially harmful tools
-- Reducing the cognitive load on the AI by limiting available options
+#### `--rt`, `--rejected_tools` Option
 
-### How It Works
+Excludes specific tools:
 
-Behind the scenes, AIA leverages a new `with_mcp` method in `RubyLLM::Chat` to set up the MCP tools for chat sessions. This method processes the hash-structured MCP tool definitions and makes them available for the AI to use during the conversation.
+```bash
+# Exclude tools with '_v1' in their filename
+--tools my_tools_directory --rejected_tools _v1
+```
 
-When you specify `--mcp` and optionally `--allowed_tools`, AIA configures the underlying `ruby_llm` adapter to connect to the appropriate MCP servers and expose only the tools you've explicitly allowed.
+Ideal for excluding older versions or temporarily disabling specific tools.
 
-### Current Limitations
+### Creating Your Own Tools
 
-As this is an experimental feature:
+To create a custom tool:
 
-- Not all AI models support MCP tools
-- The available tools may vary depending on the MCP server
-- Tool behavior may change as the MCP specification evolves
+1. Create a Ruby file that subclasses `RubyLLM::Tool`
+2. Define the tool's parameters and functionality
+3. Use the `--tools` option to load it in your AIA session
 
-### Sounds like directives
+For implementation details, refer to the [examples in the repository](examples/tools) or the RubyLLM documentation.
 
-Anthropic's MCP standard came months after the aia appeared with its inherent support of dynamic prompt context enhancements via directives, shell integration and ERB support.  Yes you can argue that if you have a working MCP client and access to appropriate MCP servers then the dynamic prompt context enhancements via directives, shell integration and ERB support are superfluous.  I don't agree with that argument.  I think the dynamic prompt context enhancements via directives, shell integration and ERB support are powerful tools in and of themselves.  I think they are a better way to do things.
+## MCP Supported
 
+Abandon all hope of seeing an MCP client added to AIA.  Maybe sometime in the future there will be a new gem "ruby_llm-mcp" that implements an MCP client as a native RubyLLM::Tool subclass.  If that every happens you would use it the same way you use any other RubyLLM::Tool subclass which AIA now supports.
 
 ## License
 

data/examples/tools/edit_file.rb

@@ -0,0 +1,26 @@
+# experiments/ai_misc/coding_agent_with_ruby_llm/tools/edit_file.rb
+
+require "ruby_llm/tool"
+
+module Tools
+  class EditFile < RubyLLM::Tool
+    description <<~DESCRIPTION
+      Make edits to a text file.
+
+      Replaces 'old_str' with 'new_str' in the given file.
+      'old_str' and 'new_str' MUST be different from each other.
+
+      If the file specified with path doesn't exist, it will be created.
+    DESCRIPTION
+    param :path, desc: "The path to the file"
+    param :old_str, desc: "Text to search for - must match exactly and must only have one match exactly"
+    param :new_str, desc: "Text to replace old_str with"
+
+    def execute(path:, old_str:, new_str:)
+      content = File.exist?(path) ? File.read(path) : ""
+      File.write(path, content.sub(old_str, new_str))
+    rescue => e
+      { error: e.message }
+    end
+  end
+end

data/examples/tools/list_files.rb

@@ -0,0 +1,18 @@
+
+# experiments/ai_misc/coding_agent_with_ruby_llm/tools/list_files.rb
+#
+require "ruby_llm/tool"
+
+module Tools
+  class ListFiles < RubyLLM::Tool
+    description "List files and directories at a given path. If no path is provided, lists files in the current directory."
+    param :path, desc: "Optional relative path to list files from. Defaults to current directory if not provided."
+
+    def execute(path: Dir.pwd)
+      Dir.glob(File.join(path, "*"))
+         .map { |filename| File.directory?(filename) ? "#{filename}/" : filename }
+    rescue => e
+      { error: e.message }
+    end
+  end
+end

data/examples/tools/read_file.rb

@@ -0,0 +1,16 @@
+# experiments/ai_misc/coding_agent_with_ruby_llm/tools/read_file.rb
+#
+"ruby_llm/tool"
+
+module Tools
+  class ReadFile < RubyLLM::Tool
+    description "Read the contents of a given relative file path. Use this when you want to see what's inside a file. Do not use this with directory names."
+    param :path, desc: "The relative path of a file in the working directory."
+
+    def execute(path:)
+      File.read(path)
+    rescue => e
+      { error: e.message }
+    end
+  end
+end

data/examples/tools/run_shell_command.rb

@@ -0,0 +1,21 @@
+# experiments/ai_misc/coding_agent_with_ruby_llm/tools/run_shell_command.rb
+
+require "ruby_llm/tool"
+
+module Tools
+  class RunShellCommand < RubyLLM::Tool
+    description "Execute a linux shell command"
+    param :command, desc: "The command to execute"
+
+    def execute(command:)
+      puts "AI wants to execute the following shell command: '#{command}'"
+      print "Do you want to execute it? (y/n) "
+      response = gets.chomp
+      return { error: "User declined to execute the command" } unless response == "y"
+
+      `#{command}`
+    rescue => e
+      { error: e.message }
+    end
+  end
+end

data/lib/aia/chat_processor_service.rb

@@ -66,11 +66,6 @@ module AIA
         client_model = AIA.client.model.id  # RubyLLM::Model instance
       end
 
-      debug_me('== dynamic model change? =='){[
-        :client_model,
-        "AIA.config.model"
-      ]}
-
       # when adapter is ruby_llm must use model.id as the name
       unless AIA.config.model.downcase.include?(client_model.downcase)
         # FIXME: assumes that the adapter is AiClient.  It might be RUbyLLM

data/lib/aia/config.rb

@@ -29,9 +29,10 @@ module AIA
       role:         '',
       system_prompt: '',
 
-      # MCP configuration
-      mcp_servers:   [],
-      allowed_tools: nil, # nil means all tools are allowed; otherwise an Array of Strings which are the tool names
+      # Tools
+      allowed_tools:  nil, # nil means all tools are allowed; otherwise an Array of Strings which are the tool names
+      rejected_tools: nil, # nil means no tools are rejected
+      tool_paths:     [],  # Strings - absolute and relative to tools
 
       # Flags
       markdown: true,
@@ -97,6 +98,9 @@ module AIA
                       )
 
       tailor_the_config(config)
+      load_tools(config)
+
+      config
     end
 
 
@@ -129,7 +133,6 @@ module AIA
         exit 1
       end
 
-
       unless config.role.empty?
         unless config.roles_prefix.empty?
           unless config.role.start_with?(config.roles_prefix)
@@ -200,16 +203,44 @@ module AIA
         PromptManager::Prompt.parameter_regex = Regexp.new(config.parameter_regex)
       end
 
-      debug_me{[ 'config.mcp_servers' ]}
+      config
+    end
+
+
+    def self.load_tools(config)
+      return if config.tool_paths.empty?
+
+      exit_on_error = false
+
+      unless config.allowed_tools.nil?
+        config.tool_paths.select! do |path|
+          config.allowed_tools.any? { |allowed| path.include?(allowed) }
+        end
+      end
+
+      unless config.rejected_tools.nil?
+        config.tool_paths.reject! do |path|
+          config.rejected_tools.any? { |rejected| path.include?(rejected) }
+        end
+      end
 
-      unless config.mcp_servers.empty?
-        # create a single JSON file contain all of the MCP server definitions specified my the --mcp option
-        config.mcp_servers = combine_mcp_server_json_files config.mcp_servers
+      config.tool_paths.each do |tool_path|
+        begin
+          # expands path based on PWD
+          absolute_tool_path = File.expand_path(tool_path)
+          require(absolute_tool_path)
+        rescue => e
+          SYSERR.puts "Error loading tool '#{tool_path}' #{e.message}"
+          exit_on_error = true
+        end
       end
 
+      exit(1) if exit_on_error
+
       config
     end
 
+
     # envar values are always String object so need other config
     # layers to know the prompter type for each key's value
     def self.envar_options(default, cli_config)
@@ -435,31 +466,36 @@ module AIA
           config.require_libs = libs.split(',')
         end
 
-        opts.on("--mcp FILE", "Add MCP server configuration from JSON file. Can be specified multiple times.") do |file|
-          # debug_me FIXME ruby-mcp-client is looking for a single JSON file that
-          # could contain multiple server definitions that looks like this:
-          # {
-          #   "mcpServers": {
-          #     "server one": { ... },
-          #     "server two": { ... }, ....
-          #   }
-          # }
-          # FIXME: need to rurn multiple JSON files into one.
-          if AIA.good_file?(file)
-            config.mcp_servers ||= []
-            config.mcp_servers << file
-            begin
-              server_config = JSON.parse(File.read(file))
-              config.mcp_servers_config ||= []
-              config.mcp_servers_config << server_config
-            rescue JSON::ParserError => e
-              STDERR.puts "Error parsing MCP server config file #{file}: #{e.message}"
+        opts.on("--tools PATH_LIST", "Add a tool(s)") do |a_path_list|
+          config.tool_paths ||= []
+
+          if a_path_list.empty?
+            STDERR.puts "No list of paths for --tools option"
+            exit 1
+          else
+            paths = a_path_list.split(',').map(&:strip).uniq
+          end
+
+          paths.each do |a_path|
+            if File.exist?(a_path)
+              if File.file?(a_path)
+                if  '.rb' == File.extname(a_path)
+                  config.tool_paths << a_path
+                else
+                  STDERR.puts "file should have *.rb extension: #{a_path}"
+                  exit 1
+                end
+              elsif File.directory?(a_path)
+                rb_files = Dir.glob(File.join(a_path, '**', '*.rb'))
+                config.tool_paths += rb_files
+              end
+            else
+              STDERR.puts "file/dir path is not valid: #{a_path}"
               exit 1
             end
-          else
-            STDERR.puts "MCP server config file not found: #{file}"
-            exit 1
           end
+
+          config.tool_paths.uniq!
         end
 
         opts.on("--at", "--allowed_tools TOOLS_LIST", "Allow only these tools to be used") do |tools_list|
@@ -472,6 +508,17 @@ module AIA
             config.allowed_tools.uniq!
           end
         end
+
+        opts.on("--rt", "--rejected_tools TOOLS_LIST", "Reject these tools") do |tools_list|
+          config.rejected_tools ||= []
+          if tools_list.empty?
+            STDERR.puts "No list of tool names provided for --rejected_tools option"
+            exit 1
+          else
+            config.rejected_tools += tools_list.split(',').map(&:strip)
+            config.rejected_tools.uniq!
+          end
+        end
       end
 
       args = ARGV.dup
@@ -557,95 +604,5 @@ module AIA
       File.write(file, content)
       puts "Config successfully dumped to #{file}"
     end
-
-
-    # Combine multiple MCP server JSON files into a single file
-    def self.combine_mcp_server_json_files(file_paths)
-      raise ArgumentError, "No JSON files provided" if file_paths.nil? || file_paths.empty?
-
-      # The output will have only one top-level key: "mcpServers"
-      mcp_servers = {} # This will store all collected server_name => server_config pairs
-
-      file_paths.each do |file_path|
-        file_content = JSON.parse(File.read(file_path))
-        # Clean basename, e.g., "filesystem.json" -> "filesystem", "foo.json.erb" -> "foo"
-        cleaned_basename = File.basename(file_path).sub(/\.json\.erb$/, '').sub(/\.json$/, '')
-
-        if file_content.is_a?(Hash)
-          if file_content.key?("mcpServers") && file_content["mcpServers"].is_a?(Hash)
-            # Case A: {"mcpServers": {"name1": {...}, "name2": {...}}}
-            file_content["mcpServers"].each do |server_name, server_data|
-              if mcp_servers.key?(server_name)
-                STDERR.puts "Warning: Duplicate MCP server name '#{server_name}' found. Overwriting with definition from #{file_path}."
-              end
-              mcp_servers[server_name] = server_data
-            end
-          # Check if the root hash itself is a single server definition
-          elsif is_single_server_definition?(file_content)
-            # Case B: {"type": "stdio", ...} or {"url": "...", ...}
-            # Use "name" property from JSON if present, otherwise use cleaned_basename
-            server_name = file_content["name"] || cleaned_basename
-            if mcp_servers.key?(server_name)
-              STDERR.puts "Warning: Duplicate MCP server name '#{server_name}' (from file #{file_path}). Overwriting."
-            end
-            mcp_servers[server_name] = file_content
-          else
-            # Case D: Fallback for {"custom_name1": {server_config1}, "custom_name2": {server_config2}}
-            # This assumes top-level keys are server names and values are server configs.
-            file_content.each do |server_name, server_data|
-              if server_data.is_a?(Hash) && is_single_server_definition?(server_data)
-                if mcp_servers.key?(server_name)
-                  STDERR.puts "Warning: Duplicate MCP server name '#{server_name}' found in #{file_path}. Overwriting."
-                end
-                mcp_servers[server_name] = server_data
-              else
-                STDERR.puts "Warning: Unrecognized structure for key '#{server_name}' in #{file_path}. Value is not a valid server definition. Skipping."
-              end
-            end
-          end
-        elsif file_content.is_a?(Array)
-          # Case C: [ {server_config1}, {server_config2_with_name} ]
-          file_content.each_with_index do |server_data, index|
-            if server_data.is_a?(Hash) && is_single_server_definition?(server_data)
-              # Use "name" property from JSON if present, otherwise generate one
-              server_name = server_data["name"] || "#{cleaned_basename}_#{index}"
-              if mcp_servers.key?(server_name)
-                STDERR.puts "Warning: Duplicate MCP server name '#{server_name}' (from array in #{file_path}). Overwriting."
-              end
-              mcp_servers[server_name] = server_data
-            else
-              STDERR.puts "Warning: Unrecognized item in array in #{file_path} at index #{index}. Skipping."
-            end
-          end
-        else
-          STDERR.puts "Warning: Unrecognized JSON structure in #{file_path}. Skipping."
-        end
-      end
-
-      # Create the final output structure
-      output    = {"mcpServers" => mcp_servers}
-      temp_file = Tempfile.new(['combined', '.json'])
-      temp_file.write(JSON.pretty_generate(output))
-      temp_file.close
-
-      temp_file.path
-    end
-
-    # Helper method to determine if a hash represents a valid MCP server definition
-    def self.is_single_server_definition?(config)
-      return false unless config.is_a?(Hash)
-      type = config['type']
-      if type
-        return true if type == 'stdio' && config.key?('command')
-        return true if type == 'sse' && config.key?('url')
-        # Potentially other explicit types if they exist in MCP
-        return false # Known type but missing required fields for it, or unknown type
-      else
-        # Infer type
-        return true if config.key?('command') || config.key?('args') || config.key?('env') # stdio
-        return true if config.key?('url') # sse
-      end
-      false
-    end
   end
 end

data/lib/aia/context_manager.rb

@@ -41,7 +41,23 @@ module AIA
         @context = [@context.first]
       else
         @context = []
-        AIA.config.client.clear_context
+      end
+
+      # 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
+        SYSERR.puts "ERROR: context_manager clear_context error #{e.message}"
       end
     end
 

data/lib/aia/directive_processor.rb

@@ -51,14 +51,28 @@ module AIA
     end
 
     def directive?(a_string)
-      a_string.strip.start_with?(PromptManager::Prompt::DIRECTIVE_SIGNAL)
+      # Handle RubyLLM::Message objects by extracting their content first
+      content = if a_string.is_a?(RubyLLM::Message)
+                 a_string.content rescue a_string.to_s
+               else
+                 a_string.to_s
+               end
+      
+      content.strip.start_with?(PromptManager::Prompt::DIRECTIVE_SIGNAL)
     end
 
     # Used with the chat loop to allow user to enter a single directive
     def process(a_string, context_manager)
       return a_string unless directive?(a_string)
 
-      key = a_string.strip
+      # Handle RubyLLM::Message objects by extracting their content first
+      content = if a_string.is_a?(RubyLLM::Message)
+                 a_string.content rescue a_string.to_s
+               else
+                 a_string.to_s
+               end
+
+      key = content.strip
       sans_prefix = key[@prefix_size..]
       args        = sans_prefix.split(' ')
       method_name = args.shift.downcase

data/lib/aia/ruby_llm_adapter.rb

@@ -1,14 +1,12 @@
 # lib/aia/ruby_llm_adapter.rb
 
 require 'ruby_llm'
-require 'mcp_client'
 
 module AIA
   class RubyLLMAdapter
-    def initialize
-
-      debug_me('=== RubyLLMAdapter ===')
+    attr_reader :tools
 
+    def initialize
       @model     = AIA.config.model
       model_info = extract_model_parts(@model)
 
@@ -26,17 +24,13 @@ module AIA
         config.bedrock_session_token = ENV.fetch('AWS_SESSION_TOKEN', nil)
       end
 
-      debug_me{[ :model_info ]}
-
-      mcp_client, mcp_tools = generate_mcp_tools(model_info[:provider])
-
-      debug_me{[ :mcp_tools ]}
+      @chat = RubyLLM.chat(model: model_info[:model])
 
-      if mcp_tools && !mcp_tools.empty?
-        RubyLLM::Chat.with_mcp(client: mcp_client, call_tool_method: :call_tool, tools: mcp_tools)
+      @tools = ObjectSpace.each_object(Class).select do |klass|
+        klass < RubyLLM::Tool
       end
 
-      @chat = RubyLLM.chat(model: model_info[:model])
+      @chat.with_tools(*tools) unless tools.empty?
     end
 
     def chat(prompt)
@@ -74,7 +68,6 @@ module AIA
     end
 
     def method_missing(method, *args, &block)
-      debug_me(tag: '== missing ==', levels: 25){[ :method, :args ]}
       if @chat.respond_to?(method)
         @chat.public_send(method, *args, &block)
       else
@@ -82,45 +75,51 @@ module AIA
       end
     end
 
+    # Clear the chat context/history
+    # Needed for the //clear directive
+    def clear_context
+      begin
+        # Option 1: Directly clear the messages array in the current chat object
+        if @chat.instance_variable_defined?(:@messages)
+          old_messages = @chat.instance_variable_get(:@messages)
+          # Force a completely empty array, not just attempting to clear it
+          @chat.instance_variable_set(:@messages, [])
+        end
+
+        # Option 2: Force RubyLLM to create a new chat instance at the global level
+        # This ensures any shared state is reset
+        model_info = extract_model_parts(@model)
+        RubyLLM.instance_variable_set(:@chat, nil) if RubyLLM.instance_variable_defined?(:@chat)
+
+        # Option 3: Create a completely fresh chat instance for this adapter
+        @chat = nil  # First nil it to help garbage collection
+        @chat = RubyLLM.chat(model: model_info[:model])
+
+        # Option 4: Call official clear_history method if it exists
+        if @chat.respond_to?(:clear_history)
+          @chat.clear_history
+        end
+
+        # Option 5: If chat has messages, force set it to empty again as a final check
+        if @chat.instance_variable_defined?(:@messages) && !@chat.instance_variable_get(:@messages).empty?
+          @chat.instance_variable_set(:@messages, [])
+        end
+
+        # Final verification
+        new_messages = @chat.instance_variable_defined?(:@messages) ? @chat.instance_variable_get(:@messages) : []
+
+        return "Chat context successfully cleared."
+      rescue => e
+        return "Error clearing chat context: #{e.message}"
+      end
+    end
+
     def respond_to_missing?(method, include_private = false)
       @chat.respond_to?(method) || super
     end
 
     private
 
-    # Generate an array of MCP tools, filtered and formatted for the correct provider.
-    # @param config [OpenStruct] the config object containing mcp_servers, allowed_tools, and model
-    # @return [Array<Hash>, nil] the filtered and formatted MCP tools or nil if no tools
-    def generate_mcp_tools(provider)
-      return [nil, nil] unless AIA.config.mcp_servers && !AIA.config.mcp_servers.empty?
-
-      debug_me('=== generate_mcp_tools ===')
-
-      # AIA.config.mcp_servers is now a path to the combined JSON file
-      mcp_client     = MCPClient.create_client(server_definition_file: AIA.config.mcp_servers)
-      debug_me
-      all_tools      = mcp_client.list_tools(cache: false).map(&:name)
-      debug_me
-      allowed        = AIA.config.allowed_tools
-      debug_me
-      filtered_tools = allowed.nil? ? all_tools : all_tools & allowed
-      debug_me{[ :filtered_tools ]}
-
-      debug_me{[ :provider ]}
-
-      mcp_tools = if :anthropic == provider.to_sym
-                    debug_me
-                    mcp_client.to_anthropic_tools(tool_names: filtered_tools)
-                  else
-                    debug_me
-                    mcp_client.to_openai_tools(tool_names: filtered_tools)
-                  end
-      [mcp_client, mcp_tools]
-    rescue => e
-      STDERR.puts "ERROR: Failed to generate MCP tools: #{e.message}"
-      nil
-    end
-
     def extract_model_parts(model_string)
       parts = model_string.split('/')
       parts.map!(&:strip)

data/lib/aia/session.rb

@@ -184,8 +184,8 @@ module AIA
         @chat_prompt = PromptManager::Prompt.new(
           id: @chat_prompt_id,
           directives_processor: @directive_processor,
-          erb_flag:             AIA.config.erb,
-          envar_flag:           AIA.config.shell,
+          erb_flag:             true,
+          envar_flag:           true,
           external_binding:     binding,
         )
 
@@ -257,6 +257,25 @@ module AIA
             directive_output = @directive_processor.process(follow_up_prompt, @context_manager)
 
             if follow_up_prompt.strip.start_with?('//clear')
+               # The directive processor has called context_manager.clear_context
+               # but we need a more aggressive approach to fully clear all context
+
+               # First, clear the context manager's context
+               @context_manager.clear_context(keep_system_prompt: true)
+
+               # Second, try clearing the client's context
+               if AIA.config.client && AIA.config.client.respond_to?(:clear_context)
+                 AIA.config.client.clear_context
+               end
+
+               # Third, completely reinitialize the client to ensure fresh state
+               # This is the most aggressive approach to ensure no context remains
+               begin
+                 AIA.config.client = AIA::RubyLLMAdapter.new
+               rescue => e
+                 SYSERR.puts "Error reinitializing client: #{e.message}"
+               end
+
                @ui_presenter.display_info("Chat context cleared.")
                next
             elsif directive_output.nil? || directive_output.strip.empty?

data/lib/aia.rb

@@ -5,10 +5,8 @@
 # provides an interface for interacting with AI models and managing prompts.
 
 require 'ruby_llm'
-require_relative 'extensions/ruby_llm/chat'
 
 require 'prompt_manager'
-require 'mcp_client'
 
 require 'debug_me'
 include DebugMe

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aia
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.2
 platform: ruby
 authors:
 - Dewayne VanHoozer
@@ -57,14 +57,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.2
+        version: 0.5.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.2
+        version: 0.5.4
 - !ruby/object:Gem::Dependency
   name: ruby_llm
   requirement: !ruby/object:Gem::Requirement
@@ -79,20 +79,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.2.0
-- !ruby/object:Gem::Dependency
-  name: ruby-mcp-client
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: reline
   requirement: !ruby/object:Gem::Requirement
@@ -302,6 +288,10 @@ files:
 - bin/aia
 - examples/README.md
 - examples/headlines
+- examples/tools/edit_file.rb
+- examples/tools/list_files.rb
+- examples/tools/read_file.rb
+- examples/tools/run_shell_command.rb
 - justfile
 - lib/aia.rb
 - lib/aia/aia_completion.bash
@@ -321,7 +311,6 @@ files:
 - lib/aia/utility.rb
 - lib/aia/version.rb
 - lib/extensions/openstruct_merge.rb
-- lib/extensions/ruby_llm/chat.rb
 - main.just
 - mcp_servers/README.md
 - mcp_servers/filesystem.json
@@ -351,7 +340,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.8
+rubygems_version: 3.6.9
 specification_version: 4
 summary: 'AI Assistant: dynamic prompts, shell & Ruby integration, and seamless chat
   workflows.'

data/lib/extensions/ruby_llm/chat.rb

@@ -1,197 +0,0 @@
-# lib/extensions/ruby_llm/chat.rb
-
-module RubyLLM
-  class Chat
-    class << self
-      # Sets up Model Control Protocol (MCP) tools
-      #
-      # @param client [instance object] MCP client instance to use
-      # @param call_tool_method [Symbol] Method name to use for tool execution
-      # @param tools [Array<Hash>] Array of MCP tool definitions
-      #
-      # @return [self] Returns self for method chaining
-      #
-      def with_mcp(client:, call_tool_method:, tools:)
-        # Validate all required parameters are present
-        if client.nil?
-          RubyLLM.logger.error "MCP setup failed: client must be provided"
-          return clear_mcp_state
-        end
-
-        if call_tool_method.nil?
-          RubyLLM.logger.error "MCP setup failed: call_tool_method must be provided"
-          return clear_mcp_state
-        end
-
-        if tools.nil?
-          RubyLLM.logger.error "MCP setup failed: tools must be provided"
-          return clear_mcp_state
-        end
-
-        # Validate call_tool_method type
-        unless call_tool_method.is_a?(Symbol) || call_tool_method.is_a?(String)
-          RubyLLM.logger.error "MCP setup failed: call_tool_method must be a Symbol or String, got #{call_tool_method.class}"
-          return clear_mcp_state
-        end
-
-        # Validate client responds to the method
-        unless client.respond_to?(call_tool_method)
-          RubyLLM.logger.error "MCP setup failed: client instance does not respond to call_tool_method #{call_tool_method}"
-          return clear_mcp_state
-        end
-
-        # Set MCP configuration
-        @mcp_client    = client
-        @mcp_call_tool = call_tool_method.to_sym
-        @mcp_tools     = tools
-
-        self
-      end
-
-      # Get the MCP client instance if configured
-      # @return [MCPClient::Client, nil] The MCP client instance or nil if not configured
-      def mcp_client
-        @mcp_client
-      end
-
-      # Get the method name to use for tool execution if configured
-      # @return [Symbol, nil] The method name or nil if not configured
-      def mcp_call_tool
-        @mcp_call_tool
-      end
-
-      # Get the MCP tool definitions if configured
-      # @return [Array<Hash>] The MCP tool definitions or empty array if not configured
-      def mcp_tools
-        @mcp_tools || []
-      end
-
-      private
-
-      # Clear all MCP state and return self
-      # @return [self]
-      def clear_mcp_state
-        @mcp_client    = nil
-        @mcp_call_tool = nil
-        @mcp_tools     = []
-        self
-      end
-    end
-
-    # Prepend a module to add MCP tool support
-    module MCPSupport
-      def initialize(...)
-        super
-        add_mcp_tools
-      end
-
-      private
-
-      def add_mcp_tools
-        self.class.mcp_tools.each do |tool_def|
-          debug_me{[ :tool_def ]}
-          tool_name = tool_def.dig(:function, :name).to_sym
-          next if @tools.key?(tool_name) # Skip if local or MCP tool exists with same name
-
-          @tools[tool_name] = MCPToolWrapper.new(tool_def)
-        end
-      end
-    end
-
-    # Add MCP support to the Chat class
-    prepend MCPSupport
-  end
-
-  # Wraps an MCP tool definition to match the RubyLLM::Tool interface
-  class MCPToolWrapper
-    def initialize(mcp_tool)
-      @mcp_tool = mcp_tool
-    end
-
-    def name
-      @mcp_tool.dig(:function, :name)
-    end
-
-    def description
-      @mcp_tool.dig(:function, :description)
-    end
-
-    # Simple parameter class that implements the interface expected by RubyLLM::Providers::OpenAI::Tools#param_schema
-    class Parameter
-      attr_reader :type, :description, :required
-      
-      def initialize(type, description, required)
-        @type = type || 'string'
-        @description = description
-        @required = required
-      end
-    end
-    
-    def parameters
-      @parameters ||= begin
-        props = @mcp_tool.dig(:function, :parameters, "properties") || {}
-        required_params = @mcp_tool.dig(:function, :parameters, "required") || []
-        
-        # Create Parameter objects with the expected interface
-        # The parameter name is the key in the properties hash
-        result = {}
-        props.each do |param_name, param_def|
-          result[param_name.to_sym] = Parameter.new(
-            param_def["type"],
-            param_def["description"],
-            required_params.include?(param_name)
-          )
-        end
-        result
-      end
-    end
-
-    def call(args)
-      # Log the tool call with arguments
-      RubyLLM.logger.debug "Tool #{name} called with: #{args.inspect}"
-
-      # Verify MCP client is configured properly
-      unless Chat.mcp_client && Chat.mcp_call_tool
-        error = { error: "MCP client not properly configured" }
-        RubyLLM.logger.error error[:error]
-        return error
-      end
-
-      # Handle tool calls that require non-string parameters
-      normalized_args = {}
-      args.each do |key, value|
-        # Convert string numbers to actual numbers when needed
-        if value.is_a?(String) && value.match?(/\A-?\d+(\.\d+)?\z/)
-          param_type = @mcp_tool.dig(:function, :parameters, "properties", key.to_s, "type")
-          if param_type == "number" || param_type == "integer"
-            normalized_args[key] = value.include?('.') ? value.to_f : value.to_i
-            next
-          end
-        end
-        normalized_args[key] = value
-      end
-      
-      # Execute the tool via the MCP client with a timeout
-      timeout = 10 # seconds
-      result = nil
-      
-      begin
-        Timeout.timeout(timeout) do
-          result = Chat.mcp_client.send(Chat.mcp_call_tool, name, normalized_args)
-        end
-      rescue Timeout::Error
-        error = { error: "MCP tool execution timed out after #{timeout} seconds" }
-        RubyLLM.logger.error error[:error]
-        return error
-      rescue StandardError => e
-        error = { error: "MCP tool execution failed: #{e.message}" }
-        RubyLLM.logger.error error[:error]
-        return error
-      end
-
-      # Log the result
-      RubyLLM.logger.debug "Tool #{name} returned: #{result.inspect}"
-      result
-    end
-  end
-end