aia 0.5.18 → 0.8.1

data/lib/aia/directive_processor.rb

@@ -0,0 +1,267 @@
+# lib/aia/directive_processor.rb
+
+module AIA
+  class DirectiveProcessor
+    EXCLUDED_METHODS = %w[ run initialize private? ]
+    @descriptions = {}
+    @aliases      = {}
+
+    class << self
+      attr_reader :descriptions, :aliases
+
+      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
+    end
+
+    def initialize
+      @prefix_size    = PromptManager::Prompt::DIRECTIVE_SIGNAL.size
+      @included_files = []
+    end
+
+    def directive?(a_string)
+      a_string.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
+      sans_prefix = key[@prefix_size..]
+      args        = sans_prefix.split(' ')
+      method_name = args.shift.downcase
+
+      if EXCLUDED_METHODS.include?(method_name)
+        return "Error: #{method_name} is not a valid directive: #{key}"
+      elsif respond_to?(method_name, true)
+        return send(method_name, args)
+      else
+        return "Error: Unknown directive '#{key}'"
+      end
+    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
+
+
+    #####################################################
+    ## Directives are implemented as private methods
+    ## All directives return a String.  It can be empty.
+    #
+    private
+
+    def private?(method_name)
+      !respond_to?(method_name) && respond_to?(method_name, true)
+    end
+
+    ################
+    ## Directives ##
+    ################
+
+    desc "Specify the next prompt ID to process after this one"
+    def next(args = [])
+      if args.empty?
+        ap AIA.config.next
+      else
+        AIA.config.next = args.shift
+      end
+      ''
+    end
+
+    desc "Specify a sequence pf prompt IDs to process after this one"
+    def pipeline(args = [])
+      if args.empty?
+        ap AIA.config.pipeline
+      else
+        AIA.config.pipeline += args.map {|id| id.gsub(',', '').strip}
+      end
+      ''
+    end
+
+    desc "Inserts the contents of a file  Example: //include path/to/file"
+    def include(args)
+      file_path = args.shift
+
+      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
+    alias_method :include_file, :include
+    alias_method :import,       :include
+
+    desc "Without arguments it will print a list of all config items and their values _or_ //config item (for one item's value) _or_ //config item = value (to set a value of an item)"
+    def config(args = [])
+      args = Array(args)
+
+      if args.empty?
+        ap AIA.config
+        ""
+      elsif args.length == 1
+        config_item = args.first
+        local_cfg   = Hash.new
+        local_cfg[config_item] = AIA.config[config_item]
+        ap local_cfg
+        ""
+      else
+        config_item  = args.shift
+        boolean      = AIA.respond_to?("#{config_item}?")
+        new_value    = args.join(' ').gsub('=', '').strip
+
+        if boolean
+          new_value = %w[true t yes y on 1 yea yeah yep yup].include?(new_value.downcase)
+        end
+
+        AIA.config[config_item] = new_value
+        ""
+      end
+    end
+    alias_method :cfg, :config
+
+    desc "Shortcut for //config top_p _and_ //config top_p = value"
+    def top_p(*args)
+      send(:config, args.prepend('top_p'))
+    end
+    alias_method :topp, :top_p
+
+    desc "Shortcut for //config model _and_ //config model = value"
+    def model(*args)
+      send(:config, args.prepend('model'))
+    end
+
+    desc "Shortcut for //config temperature _and_ //config temperature = value"
+    def temperature(*args)
+      send(:config, args.prepend('temperature'))
+    end
+    alias_method :temp, :temperature
+
+    desc "Clears the conversation history (aka context) same as //config clear = true"
+    def clear(args, context_manager)
+      if context_manager.nil?
+        return "Error: Context manager not available for //clear directive."
+      end
+      context_manager.clear_context
+      nil
+    end
+
+    desc "Shortcut for a one line of ruby code; result is added to the context"
+    def ruby(*args)
+      ruby_code = args.join(' ')
+
+      begin
+        String(eval(ruby_code))
+      rescue Exception => e
+        <<~ERROR
+          This ruby code failed: #{ruby_code}
+          #{e.message}
+        ERROR
+      end
+    end
+    alias_method :rb, :ruby
+
+    desc "Use the system's say command to speak text //say some text"
+    def say(*args)
+      `say #{args.join(' ')}`
+      ""
+    end
+
+    desc "Inserts an instruction to keep responses short and to the point."
+    def terse(*args)
+      AIA::Session::TERSE_PROMPT
+    end
+
+    desc "Display the ASCII art AIA robot."
+    def robot(*args)
+      AIA::Utility.robot
+      ""
+    end
+
+    desc "Generates this help content"
+    def help(*args)
+      puts
+      puts "Available Directives"
+      puts "===================="
+      puts
+
+      directives  = self.class
+                      .private_instance_methods(false)
+                      .map(&:to_s)
+                      .reject { |m| EXCLUDED_METHODS.include?(m) }
+                      .sort
+
+      self.class.build_aliases(directives)
+
+      directives.each do |directive|
+        next unless self.class.descriptions[directive]
+
+        others = self.class.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} #{self.class.descriptions[directive]}
+          #{others_line}
+        TEXT
+      end
+
+      ""
+    end
+  end
+end

data/lib/aia/{tools/fzf.rb → fzf.rb}

@@ -4,16 +4,7 @@
 require 'shellwords'
 require 'tempfile'
 
-class AIA::Fzf < AIA::Tools
-
-  meta(
-    name:     'fzf',
-    role:     :search_tool,
-    desc:     "A command-line fuzzy finder",
-    url:      "https://github.com/junegunn/fzf",
-    install:  "brew install fzf",
-  )
-
+class AIA::Fzf
   DEFAULT_PARAMETERS = %w[
     --tabstop=2
     --header-first
@@ -39,26 +30,27 @@ class AIA::Fzf < AIA::Tools
     @subject    = subject
     @prompt     = prompt
     @extension  = extension
-    
+
     build_command
   end
 
 
   def build_command
     fzf_options = DEFAULT_PARAMETERS.dup
-    fzf_options << "--header='#{subject} which contain: #{query}\\nPress ESC to cancel.'"
+    fzf_options << "--header='#{subject} which contain: #{query}\nPress ESC to cancel.'"
     fzf_options << "--preview='cat #{directory}/{1}#{extension}'"
     fzf_options << "--prompt=#{Shellwords.escape(prompt)}"
-    
-    fzf_command = "#{meta.name} #{fzf_options.join(' ')}"
+
+    fzf_command = "fzf #{fzf_options.join(' ')}"
 
     @command = "cat #{tempfile_path} | #{fzf_command}"
   end
-  
+
 
   def run
-    puts "Executing: #{@command}"
-    selected = `#{@command}`
+    # puts "Executing: #{@command}"
+    selected = `#{@command}`.strip
+
     selected.strip.empty? ? nil : selected.strip
   ensure
     unlink_tempfile

data/lib/aia/history_manager.rb

@@ -0,0 +1,85 @@
+# lib/aia/history_manager.rb
+
+require 'json'
+require 'fileutils'
+
+module AIA
+  class HistoryManager
+    MAX_VARIABLE_HISTORY = 5
+
+    # prompt is PromptManager::Prompt instance
+    def initialize(prompt:)
+      @prompt  = prompt
+      @history = []
+    end
+
+
+    def history
+      @history
+    end
+
+
+    def history=(new_history)
+      @history = new_history
+    end
+
+
+    def setup_variable_history(history_values)
+      Reline::HISTORY.clear
+      history_values.each do |value|
+        Reline::HISTORY.push(value) unless value.nil? || value.empty?
+      end
+    end
+
+
+    def get_variable_history(variable, value = '')
+      return if value.nil? || value.empty?
+
+      values = @prompt.parameters[variable]
+      if values.include?(value)
+        values.delete(value)
+      end
+
+      values << value
+
+      if values.size > MAX_VARIABLE_HISTORY
+        values.shift
+      end
+
+      @prompt.parameters[variable] = values
+    end
+
+
+    def request_variable_value(variable_name:, history_values: [])
+      setup_variable_history(history_values) # Setup Reline's history for completion
+
+      default_value = history_values.last || ''
+      question = "Value for #{variable_name} (#{default_value}): "
+
+      # Ensure Reline is writing to stdout explicitly for this interaction
+      Reline.output = $stdout
+
+      # Store the original prompt proc to restore later
+      original_prompt_proc = Reline.line_editor.prompt_proc
+
+      # Note: Temporarily setting prompt_proc might not be needed if passing prompt to readline works.
+      # Reline.line_editor.prompt_proc = ->(context) { [question] }
+
+      begin
+        input = Reline.readline(question, true)
+        return default_value if input.nil? # Handle Ctrl+D -> use default
+
+        chosen_value = input.strip.empty? ? default_value : input.strip
+        # Update the persistent history for this variable
+        get_variable_history(variable_name, chosen_value)
+        return chosen_value
+      rescue Interrupt
+        puts "\nVariable input interrupted."
+        exit(1) # Exit cleanly on Ctrl+C
+      ensure
+        # Restore the original prompt proc
+        Reline.line_editor.prompt_proc = original_prompt_proc
+      end
+    end
+  end
+end

data/lib/aia/prompt_handler.rb

@@ -0,0 +1,178 @@
+# lib/aia/prompt_handler.rb
+
+require 'prompt_manager'
+require 'prompt_manager/storage/file_system_adapter'
+require 'erb'
+
+
+module AIA
+  class PromptHandler
+    def initialize
+      @prompts_dir         = AIA.config.prompts_dir
+      @roles_dir           = AIA.config.roles_dir # A sub-directory of @prompts_dir
+      @directive_processor = AIA::DirectiveProcessor.new
+
+      PromptManager::Prompt.storage_adapter =
+        PromptManager::Storage::FileSystemAdapter.config do |c|
+          c.prompts_dir      = @prompts_dir
+          c.prompt_extension = '.txt'  # default
+          c.params_extension = '.json' # default
+        end.new
+    end
+
+
+    def get_prompt(prompt_id, role_id = '')
+      prompt = fetch_prompt(prompt_id)
+
+      unless role_id.empty?
+        role_prompt = fetch_role(role_id)
+        prompt.text.prepend(role_prompt.text)
+      end
+
+      prompt
+    end
+
+    def fetch_prompt(prompt_id)
+      # Special case for fuzzy search without an initial query
+      if prompt_id == '__FUZZY_SEARCH__'
+        return fuzzy_search_prompt('')
+      end
+
+      # First check if the prompt file exists to avoid ArgumentError from PromptManager
+      prompt_file_path = File.join(@prompts_dir, "#{prompt_id}.txt")
+      if File.exist?(prompt_file_path)
+        prompt = PromptManager::Prompt.new(
+          id: prompt_id,
+          directives_processor: @directive_processor,
+          external_binding: binding,
+          erb_flag: AIA.config.erb,
+          envar_flag: AIA.config.shell
+        )
+
+        return prompt if prompt
+      else
+        puts "Warning: Invalid prompt ID or file not found: #{prompt_id}"
+      end
+
+      handle_missing_prompt(prompt_id)
+    end
+
+    def handle_missing_prompt(prompt_id)
+      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}"
+      else
+        raise "Error: Could not find prompt with ID: #{prompt_id}"
+      end
+    end
+
+    def fuzzy_search_prompt(prompt_id)
+      new_prompt_id = search_prompt_id_with_fzf(prompt_id)
+
+      if new_prompt_id.nil? || new_prompt_id.empty?
+        raise "Error: Could not find prompt with ID: #{prompt_id} even with fuzzy search"
+      end
+
+      prompt = PromptManager::Prompt.new(
+        id: new_prompt_id,
+        directives_processor: @directive_processor,
+        external_binding: binding,
+        erb_flag: AIA.config.erb,
+        envar_flag: AIA.config.shell
+      )
+
+      raise "Error: Could not find prompt with ID: #{prompt_id} even with fuzzy search" if prompt.nil?
+
+      prompt
+    end
+
+    def fetch_role(role_id)
+      # Prepend roles_prefix if not already present
+      unless role_id.start_with?(AIA.config.roles_prefix)
+        role_id = "#{AIA.config.roles_prefix}/#{role_id}"
+      end
+
+      # NOTE: roles_prefix is a sub-directory of the prompts directory
+      role_file_path = File.join(@prompts_dir, "#{role_id}.txt")
+
+      if File.exist?(role_file_path)
+        role_prompt = PromptManager::Prompt.new(
+          id: role_id,
+          directives_processor: @directive_processor,
+          external_binding: binding,
+          erb_flag: AIA.config.erb,
+          envar_flag: AIA.config.shell
+        )
+        return role_prompt if role_prompt
+      else
+        puts "Warning: Invalid role ID or file not found: #{role_id}"
+      end
+
+      handle_missing_role(role_id)
+    end
+
+    def handle_missing_role(role_id)
+      if AIA.config.fuzzy
+        return fuzzy_search_role(role_id)
+      else
+        raise "Error: Could not find role with ID: #{role_id}"
+      end
+    end
+
+    def fuzzy_search_role(role_id)
+      new_role_id = search_role_id_with_fzf(role_id)
+      if new_role_id.nil? || new_role_id.empty?
+        raise "Error: Could not find role with ID: #{role_id} even with fuzzy search"
+      end
+
+      role_prompt = PromptManager::Prompt.new(
+        id: new_role_id,
+        directives_processor: @directive_processor,
+        external_binding: binding,
+        erb_flag: AIA.config.erb,
+        envar_flag: AIA.config.shell
+      )
+
+      raise "Error: Could not find role with ID: #{role_id} even with fuzzy search" if role_prompt.nil?
+      role_prompt
+    end
+
+
+    def search_prompt_id_with_fzf(initial_query)
+      prompt_files = Dir.glob(File.join(@prompts_dir, "*.txt")).map { |file| File.basename(file, ".txt") }
+      fzf = AIA::Fzf.new(
+        list: prompt_files,
+        directory: @prompts_dir,
+        query: initial_query,
+        subject: 'Prompt IDs',
+        prompt: 'Select a prompt ID:'
+      )
+      fzf.run || (raise "No prompt ID selected")
+    end
+
+    def search_role_id_with_fzf(initial_query)
+      role_files = Dir.glob(File.join(@roles_dir, "*.txt")).map { |file| File.basename(file, ".txt") }
+      fzf = AIA::Fzf.new(
+        list: role_files,
+        directory: @prompts_dir,
+        query: initial_query,
+        subject: 'Role IDs',
+        prompt: 'Select a role ID:'
+      )
+
+      role = fzf.run
+
+      if role.nil? || role.empty?
+        raise "No role ID selected"
+      end
+
+      unless role.start_with?(AIA.config.role_prefix)
+        role = AIA.config.role_prefix + '/' + role
+      end
+
+      role
+    end
+  end
+end