aia 0.9.11 → 0.9.12

data/lib/aia/directives/models.rb

@@ -0,0 +1,178 @@
+# lib/aia/directives/models.rb
+
+module AIA
+  module Directives
+    module Models
+      class << self
+        def descriptions
+          @descriptions ||= {}
+        end
+
+        def aliases
+          @aliases ||= {}
+        end
+
+        def build_aliases(methods)
+          methods.each do |method_name|
+            method = self.method(method_name)
+            aliases[method_name] = []
+
+            methods.each do |other_method_name|
+              next if method_name == other_method_name
+              other_method = self.method(other_method_name)
+
+              if method == other_method
+                aliases[method_name] << other_method_name
+              end
+            end
+          end
+        end
+      end
+
+      def self.available_models(args = nil, context_manager = nil)
+          query = args
+
+          if 1 == query.size
+            query = query.first.split(',')
+          end
+
+          header = "\nAvailable LLMs"
+          header += " for #{query.join(' and ')}" if query
+
+          puts header + ':'
+          puts
+
+          q1 = query.select { |q| q.include?('_to_') } # SMELL: ??
+          q2 = query.reject { |q| q.include?('_to_') }
+
+          counter = 0
+
+          RubyLLM.models.all.each do |llm|
+            cw = llm.context_window
+            caps = llm.capabilities.join(',')
+            inputs = llm.modalities.input.join(',')
+            outputs = llm.modalities.output.join(',')
+            mode = "#{inputs} to #{outputs}"
+            in_1m = llm.pricing.text_tokens.standard.to_h[:input_per_million]
+            entry = "- #{llm.id} (#{llm.provider}) in: $#{in_1m} cw: #{cw} mode: #{mode} caps: #{caps}"
+
+            if query.nil? || query.empty?
+              counter += 1
+              puts entry
+              next
+            end
+
+            show_it = true
+            q1.each { |q| show_it &&= llm.modalities.send("#{q}?") }
+            q2.each { |q| show_it &&= entry.include?(q) }
+
+            if show_it
+              counter += 1
+              puts entry
+            end
+          end
+
+          puts if counter > 0
+          puts "#{counter} LLMs matching your query"
+          puts
+
+          ""
+        end
+
+      def self.help(args = nil, context_manager = nil)
+          puts
+          puts "Available Directives"
+          puts "===================="
+          puts
+
+          directives = self.methods(false).map(&:to_s).reject do |m|
+            ['run', 'initialize', 'private?', 'descriptions', 'aliases', 'build_aliases'].include?(m)
+          end.sort
+
+          build_aliases(directives)
+
+          directives.each do |directive|
+            next unless descriptions[directive]
+
+            others = aliases[directive]
+
+            if others.empty?
+              others_line = ""
+            else
+              with_prefix = others.map { |m| PromptManager::Prompt::DIRECTIVE_SIGNAL + m }
+              others_line = "\tAliases:#{with_prefix.join('  ')}\n"
+            end
+
+            puts <<~TEXT
+              //#{directive} #{descriptions[directive]}
+              #{others_line}
+            TEXT
+          end
+
+          ""
+        end
+
+      def self.compare(args, context_manager = nil)
+          return 'Error: No prompt provided for comparison' if args.empty?
+
+          # Parse arguments - first arg is the prompt, --models flag specifies models
+          prompt = nil
+          models = []
+
+          i = 0
+          while i < args.length
+            if args[i] == '--models' && i + 1 < args.length
+              models = args[i + 1].split(',')
+              i += 2
+            else
+              prompt ||= args[i]
+              i += 1
+            end
+          end
+
+          return 'Error: No prompt provided for comparison' unless prompt
+          return 'Error: No models specified. Use --models model1,model2,model3' if models.empty?
+
+          puts "\nComparing responses for: #{prompt}\n"
+          puts '=' * 80
+
+          results = {}
+
+          models.each do |model_name|
+            model_name.strip!
+            puts "\n🤖 **#{model_name}:**"
+            puts '-' * 40
+
+            begin
+              # Create a temporary chat instance for this model
+              chat = RubyLLM.chat(model: model_name)
+              response = chat.ask(prompt)
+              content = response.content
+
+              puts content
+              results[model_name] = content
+            rescue StandardError => e
+              error_msg = "Error with #{model_name}: #{e.message}"
+              puts error_msg
+              results[model_name] = error_msg
+            end
+          end
+
+          puts '\n' + '=' * 80
+          puts "\nComparison complete!"
+
+          ''
+        end
+
+      # Set up aliases - these work on the module's singleton class
+      class << self
+        alias_method :am, :available_models
+        alias_method :available, :available_models
+        alias_method :models, :available_models
+        alias_method :all_models, :available_models
+        alias_method :llms, :available_models
+        alias_method :cmp, :compare
+      end
+    end
+  end
+end

data/lib/aia/directives/registry.rb

@@ -0,0 +1,120 @@
+# lib/aia/directives/registry.rb
+
+require_relative 'web_and_file'
+require_relative 'utility'
+require_relative 'configuration'
+require_relative 'execution'
+require_relative 'models'
+
+module AIA
+  module Directives
+    module Registry
+      EXCLUDED_METHODS = %w[ run initialize private? ]
+
+      class << self
+        def descriptions
+          @descriptions ||= {}
+        end
+
+        def aliases
+          @aliases ||= {}
+        end
+
+        def desc(description, method_name = nil)
+          @last_description = description
+          descriptions[method_name.to_s] = description if method_name
+          nil
+        end
+
+        def method_added(method_name)
+          if @last_description
+            descriptions[method_name.to_s] = @last_description
+            @last_description = nil
+          end
+          super if defined?(super)
+        end
+
+        def build_aliases(private_methods)
+          private_methods.each do |method_name|
+            method = instance_method(method_name)
+
+            aliases[method_name] = []
+
+            private_methods.each do |other_method_name|
+              next if method_name == other_method_name
+
+              other_method = instance_method(other_method_name)
+
+              if method == other_method
+                aliases[method_name] << other_method_name
+              end
+            end
+          end
+        end
+
+        def register_directive_module(mod)
+          @directive_modules ||= []
+          @directive_modules << mod
+        end
+
+        def process(directive_name, args, context_manager)
+          if EXCLUDED_METHODS.include?(directive_name)
+            return "Error: #{directive_name} is not a valid directive"
+          end
+          
+          # Check all registered directive modules
+          @directive_modules ||= []
+          @directive_modules.each do |mod|
+            if mod.respond_to?(directive_name)
+              return mod.send(directive_name, args, context_manager)
+            end
+          end
+          
+          return "Error: Unknown directive '#{directive_name}'"
+        end
+
+        def run(directives)
+          return {} if directives.nil? || directives.empty?
+
+          directives.each do |key, _|
+            sans_prefix = key[prefix_size..]
+            args = sans_prefix.split(' ')
+            method_name = args.shift.downcase
+
+            if EXCLUDED_METHODS.include?(method_name)
+              directives[key] = "Error: #{method_name} is not a valid directive: #{key}"
+              next
+            elsif respond_to?(method_name, true)
+              directives[key] = send(method_name, args)
+            else
+              directives[key] = "Error: Unknown directive '#{key}'"
+            end
+          end
+
+          directives
+        end
+
+        def prefix_size
+          PromptManager::Prompt::DIRECTIVE_SIGNAL.size
+        end
+
+        def directive?(string)
+          content = if string.is_a?(RubyLLM::Message)
+                     string.content rescue string.to_s
+                   else
+                     string.to_s
+                   end
+
+          content.strip.start_with?(PromptManager::Prompt::DIRECTIVE_SIGNAL)
+        end
+      end
+
+      # Register all directive modules
+      register_directive_module(WebAndFile)
+      register_directive_module(Utility)
+      register_directive_module(Configuration)
+      register_directive_module(Execution)
+      register_directive_module(Models)
+    end
+  end
+end

data/lib/aia/directives/utility.rb

@@ -0,0 +1,70 @@
+# lib/aia/directives/utility.rb
+
+require 'tty-screen'
+require 'word_wrapper'
+
+module AIA
+  module Directives
+    module Utility
+      TERSE_PROMPT = "\nKeep your response short and to the point.\n"
+
+      def self.tools(args = [], context_manager = nil)
+          indent = 4
+          spaces = " " * indent
+          width = TTY::Screen.width - indent - 2
+
+          if AIA.config.tools.empty?
+            puts "No tools are available"
+          else
+            puts
+            puts "Available Tools"
+            puts "==============="
+
+            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
+            end
+          end
+          puts
+
+          ''
+        end
+
+      def self.next(args = [], context_manager = nil)
+          if args.empty?
+            ap AIA.config.next
+          else
+            AIA.config.next = args.shift
+          end
+          ''
+        end
+
+      def self.pipeline(args = [], context_manager = nil)
+          if args.empty?
+            ap AIA.config.pipeline
+          elsif 1 == args.size
+            AIA.config.pipeline += args.first.split(',').map(&:strip).reject { |id| id.empty? }
+          else
+            AIA.config.pipeline += args.map { |id| id.gsub(',', '').strip }.reject { |id| id.empty? }
+          end
+          ''
+        end
+
+      def self.terse(args, context_manager = nil)
+          TERSE_PROMPT
+        end
+
+      def self.robot(args, context_manager = nil)
+          AIA::Utility.robot
+          ""
+        end
+
+      # Set up aliases - these work on the module's singleton class
+      class << self
+        alias_method :workflow, :pipeline
+      end
+    end
+  end
+end

data/lib/aia/directives/web_and_file.rb

@@ -0,0 +1,71 @@
+# lib/aia/directives/web_and_file.rb
+
+require 'faraday'
+require 'active_support/all'
+
+module AIA
+  module Directives
+    module WebAndFile
+      PUREMD_API_KEY = ENV.fetch('PUREMD_API_KEY', nil)
+
+      def self.webpage(args, context_manager = nil)
+          if PUREMD_API_KEY.nil?
+            "ERROR: PUREMD_API_KEY is required in order to include a webpage"
+          else
+            url = `echo #{args.shift}`.strip
+            puremd_url = "https://pure.md/#{url}"
+
+            response = Faraday.get(puremd_url) do |req|
+              req.headers['x-puremd-api-token'] = PUREMD_API_KEY
+            end
+
+            if 200 == response.status
+              response.body
+            else
+              "Error: Status was #{response.status}\n#{ap response}"
+            end
+          end
+        end
+
+      def self.include(args, context_manager = nil)
+          # echo takes care of envars and tilde expansion
+          file_path = `echo #{args.shift}`.strip
+
+          if file_path.start_with?(/http?:\/\//)
+            webpage(args)
+          else
+            include_file(file_path)
+          end
+        end
+
+        def self.include_file(file_path)
+          @included_files ||= []
+          if @included_files.include?(file_path)
+            ""
+          else
+            if File.exist?(file_path) && File.readable?(file_path)
+              @included_files << file_path
+              File.read(file_path)
+            else
+              "Error: File '#{file_path}' is not accessible"
+            end
+          end
+        end
+
+      def self.included_files
+        @included_files ||= []
+      end
+
+      def self.included_files=(files)
+        @included_files = files
+      end
+
+      # Set up aliases - these work on the module's singleton class
+      class << self
+        alias_method :website, :webpage
+        alias_method :web, :webpage  
+        alias_method :import, :include
+      end
+    end
+  end
+end

data/lib/aia/prompt_handler.rb

@@ -59,13 +59,22 @@ module AIA
     end
 
     def handle_missing_prompt(prompt_id)
+      # Handle empty/nil prompt_id
+      prompt_id = prompt_id.to_s.strip
+      if prompt_id.empty?
+        STDERR.puts "Error: Prompt ID cannot be empty"
+        exit 1
+      end
+      
       if AIA.config.fuzzy
         return fuzzy_search_prompt(prompt_id)
       elsif AIA.config.fuzzy
         puts "Warning: Fuzzy search is enabled but Fzf tool is not available."
-        raise "Error: Could not find prompt with ID: #{prompt_id}"
+        STDERR.puts "Error: Could not find prompt with ID: #{prompt_id}"
+        exit 1
       else
-        raise "Error: Could not find prompt with ID: #{prompt_id}"
+        STDERR.puts "Error: Could not find prompt with ID: #{prompt_id}"
+        exit 1
       end
     end
 
@@ -90,6 +99,9 @@ module AIA
     end
 
     def fetch_role(role_id)
+      # Handle nil role_id
+      return handle_missing_role("roles/") if role_id.nil?
+      
       # Prepend roles_prefix if not already present
       unless role_id.start_with?(AIA.config.roles_prefix)
         role_id = "#{AIA.config.roles_prefix}/#{role_id}"
@@ -115,10 +127,18 @@ module AIA
     end
 
     def handle_missing_role(role_id)
+      # Handle empty/nil role_id
+      role_id = role_id.to_s.strip
+      if role_id.empty? || role_id == "roles/"
+        STDERR.puts "Error: Role ID cannot be empty"
+        exit 1
+      end
+      
       if AIA.config.fuzzy
         return fuzzy_search_role(role_id)
       else
-        raise "Error: Could not find role with ID: #{role_id}"
+        STDERR.puts "Error: Could not find role with ID: #{role_id}"
+        exit 1
       end
     end