aia 0.3.4 → 0.3.20

data/lib/aia/prompt_processing.rb

@@ -5,14 +5,20 @@ module AIA::PromptProcessing
 
   # Fetch the first argument which should be the prompt id
   def get_prompt
-    prompt_id = @arguments.shift
+    prompt_id = AIA.config.arguments.shift
 
     # TODO: or maybe go to a generic search and select process
 
+    # TODO: if external options were provided but no prompt id
+    #       then by pass prompt process and send the extra
+    #       options to the backend.  For example:
+    #         aia -- --settings
+    #       should send --settings to mods and nothing else
+    
     abort("Please provide a prompt id") unless prompt_id
 
     search_for_a_matching_prompt(prompt_id) unless existing_prompt?(prompt_id)
-    edit_prompt if edit?
+    edit_prompt if AIA.config.edit?
   end
 
 
@@ -178,8 +184,17 @@ module AIA::PromptProcessing
 
 
   def edit_prompt
-    `#{EDITOR} #{@prompt.path}`
-    @options[:edit?][0] = false
+    # FIXME: replace with the editor from the configuration
+    
+    @editor   = AIA::Subl.new(
+                  file: @prompt.path
+                )
+    
+    @editor.run # blocks until file is closed
+
+    @options[:edit?][0] = false # turn off the --edit switch
+
+    # reload the edited prompt
     @prompt = PromptManager::Prompt.get(id: @prompt.id)
   end
 
@@ -210,3 +225,192 @@ module AIA::PromptProcessing
   end
 end
 
+
+
+__END__
+
+# lib/aia/prompt_processing.rb
+
+class AIA::PromptProcessing
+  KW_HISTORY_MAX = 5
+  
+  def initialize(arguments, options)
+    @arguments = arguments
+    @options = options
+    @prompt = nil
+  end
+
+  def execute
+    get_prompt
+    process_prompt
+  end
+
+  private
+  
+  def get_prompt
+    prompt_id = @arguments.shift
+    abort("Please provide a prompt id") unless prompt_id
+    search_for_a_matching_prompt(prompt_id) unless existing_prompt?(prompt_id)
+    edit_prompt if edit?
+  end
+
+  def existing_prompt?(prompt_id)
+    @prompt = PromptManager::Prompt.get(id: prompt_id)
+    @prompt.keywords.each do |kw|
+      @prompt.parameters[kw] = Array(@prompt.parameters[kw])
+    end
+    true
+  rescue ArgumentError
+    false
+  end
+
+  def process_prompt
+    return if @prompt.keywords.empty?
+    replace_keywords
+    @prompt.build
+    @prompt.save
+  end
+
+  def replace_keywords
+    puts "ID: #{@prompt.id}"
+    show_prompt_without_comments
+    puts_instructions
+    @prompt.keywords.each do |kw|
+      value = keyword_value(kw, @prompt.parameters[kw])
+      update_keyword_history(kw, value) unless value.nil? || value.strip.empty?
+    end
+  end
+
+  def puts_instructions
+    puts "\nPress up/down arrow to scroll through history."
+    puts "Type new input or edit the current input."
+    puts  "Quit #{MY_NAME} with a CNTL-D or a CNTL-C"
+    puts
+  end
+
+  def update_keyword_history(kw, value)
+    params = @prompt.parameters[kw]
+    params.delete(value)
+    params << value
+    params.shift if params.size > KW_HISTORY_MAX
+  end
+
+  def keyword_value(kw, history_array)
+    Readline::HISTORY.clear
+    Array(history_array).each { |entry| Readline::HISTORY.push(entry) unless entry.nil? || entry.empty? }
+    puts "Parameter #{kw} ..."
+    begin
+      a_string = Readline.readline("\n-=> ", true)
+    rescue Interrupt
+      a_string = nil
+    end
+    abort("okay. Come back soon.") if a_string.nil?
+    a_string.empty? ? history_array.first : a_string
+  end
+
+  def search_for_a_matching_prompt(prompt_id)
+    found_prompts = PromptManager::Prompt.search(prompt_id)
+    handle_no_prompts_found(prompt_id) if found_prompts.empty?
+    prompt_id = found_prompts.size == 1 ? found_prompts.first : handle_multiple_prompts(found_prompts, prompt_id)
+    @prompt = PromptManager::Prompt.get(id: prompt_id)
+  end
+
+  def handle_no_prompts_found(prompt_id)
+    if edit?
+      create_prompt(prompt_id)
+      edit_prompt
+    else
+      abort_no_prompts_error(prompt_id)
+    end
+  end
+
+  def abort_no_prompts_error(prompt_id)
+    abort <<~EOS
+    
+      No prompts were found for: #{prompt_id}
+      To create a prompt with this ID use the --edit option
+      like this:
+        #{MY_NAME} #{prompt_id} --edit
+
+    EOS
+  end
+
+  def handle_multiple_prompts(found_these, while_looking_for_this)
+    raise ArgumentError, "Argument is not an Array" unless found_these.is_a?(Array)
+    result = execute_fzf(found_these, while_looking_for_this)
+    abort unless result
+    result
+  end
+
+  def execute_fzf(found_these, while_looking_for_this)
+    fzf_options = build_fzf_options(while_looking_for_this)
+    temp_file = create_tempfile_with_entries(found_these)
+    selected = `cat #{temp_file.path} | fzf #{fzf_options}`.strip
+    temp_file.unlink
+    selected.empty? ? nil : selected
+  end
+
+  def build_fzf_options(search_term)
+    [
+      "--tabstop=2",
+      "--header='Prompt IDs which contain: #{search_term}\nPress ESC to cancel.'",
+      "--header-first",
+      "--prompt='Search term: '",
+      '--delimiter :',
+      "--preview 'cat $PROMPTS_DIR/{1}.txt'",
+      "--preview-window=down:50%:wrap"
+    ].join(' ')
+  end
+
+  def create_tempfile_with_entries(entries)
+    temp_file = Tempfile.new('fzf-input')
+    temp_file.puts(entries)
+    temp_file.close
+    temp_file
+  end
+
+  def create_prompt(prompt_id)
+    @prompt = PromptManager::Prompt.create(id: prompt_id)
+    # Additional prompt config...
+  end
+
+
+
+  def edit_prompt
+    # FIXME: replace with the editor from the configuration
+    
+    @editor   = AIA::Subl.new(
+                  file: @prompt.path
+                )
+    
+    @editor.run # blocks until file is closed
+
+    @options[:edit?][0] = false # turn off the --edit switch
+
+    # reload the edited prompt
+    @prompt = PromptManager::Prompt.get(id: @prompt.id)
+  end
+
+
+  def show_prompt_without_comments
+    puts remove_comments.wrap(indent: 4)
+  end
+
+  def remove_comments
+    lines = @prompt.text.lines
+             .reject { |a_line| a_line.strip.start_with?('#') }
+             .drop_while(&:empty?)
+    logical_end_inx = lines.index("__END__")
+    lines = lines[0...logical_end_inx] if logical_end_inx
+    lines.join("\n")
+  end
+  
+  def edit?
+    @options[:edit?] && @options[:edit?][0] == true
+  end
+end
+
+
+
+
+

data/lib/aia/tools/editor.rb

@@ -0,0 +1,52 @@
+# lib/aia/tools/editor.rb
+# This is the default editor setup in the
+# system environment variable EDITOR
+
+
+class AIA::Editor < AIA::Tools
+
+  meta(
+    name:     'editor',
+    role:     :editor,
+    desc:     "Your default system $EDITOR",
+    url:      "unknown",
+    install:  "should already be installed",
+  )
+
+  DEFAULT_PARAMETERS = ""
+  
+  attr_accessor :command
+
+
+  def initialize(file: "")    
+    @file     = file
+
+    discover_editor
+
+    build_command
+  end
+
+
+  def discover_editor
+    editor = ENV['EDITOR']  # This might be nil
+
+    if editor.nil?
+      @name         = "echo"
+      @description  = "You have no default editor"
+      @install      = "Set your system environment variable EDITOR"
+    else
+      @name = editor
+    end    
+  end
+
+
+  def build_command
+    @command = "#{meta.name} #{DEFAULT_PARAMETERS} #{@file}"
+  end
+
+  
+  def run
+    `#{command}`
+  end
+end
+

data/lib/aia/{external → tools}/mods.rb

@@ -1,22 +1,118 @@
-# lib/aia/external/mods.rb
-
-class AIA::External::Mods < AIA::External::Tool
-  def initialize
-    super
-    @role = :search
-    @desc = 'AI on the command-line'
-    @url  = 'https://github.com/charmbracelet/mods'
+# lib/aia/tools/mods.rb
+
+class AIA::Mods < AIA::Tools
+
+  meta(
+    name:     'mods',
+    role:     :backend,
+    desc:     'AI on the command-line',
+    url:      'https://github.com/charmbracelet/mods',
+    install:  'brew install mods',
+  )
+
+  
+  DEFAULT_PARAMETERS = [
+    "--no-limit"              # no limit on input context
+  ].join(' ').freeze
+
+  attr_accessor :command, :text, :files
+
+
+  def initialize(
+      text:           "", # prompt text after keyword replacement
+      files:          []  # context file paths (Array of Pathname)
+    )
+
+    @text           = text
+    @files          = files
+
+    build_command
   end
 
-  def command(extra_options = [])
-    model = ENV['MODS_MODEL'] || 'gpt-4-1106-preview'
-    ai_default_opts = "-m #{model} --no-limit -f"
-    "#{name} #{ai_default_opts} #{extra_options.join(' ')}"
+
+  def sanitize(input)
+    Shellwords.escape(input)
+  end
+
+
+  def build_command
+    parameters  = DEFAULT_PARAMETERS.dup + " "
+    parameters += "-f "                     if AIA.config.markdown?
+    parameters += "-m #{AIA.config.model} " if AIA.config.model
+    parameters += AIA.config.extra
+    @command    = "mods #{parameters} "
+    @command   += sanitize(@text)
+
+    # context = @files.join(' ')
+    #
+    # unless context.empty?
+    #   if @files.size > 1
+    #     # FIXME:  This syntax breaks mods which does not know how
+    #     #         to read the temporary file descriptor created
+    #     #         by the shell
+    #     @command += " <(cat #{context})"
+    #   else
+    #     @command += " < #{context}"
+    #   end
+    # end
+
+    @command
+  end
+
+
+  def run
+    case @files.size
+    when 0
+      @result = `#{build_command}`
+    when 1
+      @result = `#{build_command} < #{@files.first}`
+    else
+      create_temp_file_with_contexts
+      run_mods_with_temp_file
+      clean_up_temp_file
+    end
+    
+    @result
+  end
+  
+  
+  # Create a temporary file that concatenates all contexts,
+  # to be used as STDIN for the 'mods' utility
+  def create_temp_file_with_contexts
+    @temp_file = Tempfile.new('mods-context')
+
+    @files.each do |file|
+      content = File.read(file)
+      @temp_file.write(content)
+      @temp_file.write("\n")
+    end
+
+    @temp_file.close
+  end
+  
+
+  # Run 'mods' with the temporary file as STDIN
+  def run_mods_with_temp_file
+    command = "#{build_command} < #{@temp_file.path}"
+    @result = `#{command}`
+  end
+  
+
+  # Clean up the temporary file after use
+  def clean_up_temp_file
+    @temp_file.unlink if @temp_file
   end
 end
 
 __END__
 
+
+    
+
+
+##########################################################
+
+
 GPT on the command line. Built for pipelines.
 
 Usage:

data/lib/aia/{external → tools}/sgpt.rb

@@ -1,12 +1,17 @@
-# lib/aia/external/sgpt.rb
+# lib/aia/tools/sgpt.rb
+
+class AIA::Sgpt < AIA::Tools
+
+  meta(
+    name:     'sgpt',
+    role:     :backend,
+    desc:     "shell-gpt",
+    url:      "https://github.com/TheR1D/shell_gpt",
+    install:  "pip install shell-gpt",
+  )
 
-class AIA::External::Sgpt < AIA::External::Tool
   def initialize
-    super
-    @role     = :backend
-    @desc     = "shell-gpt"
-    @url      = "https://github.com/TheR1D/shell_gpt"
-    @install  = "pip install shell-gpt"
+    # TODO: something
   end
 end
 

data/lib/aia/{external → tools}/subl.rb

@@ -1,17 +1,38 @@
-# lib/aia/external/subl.rb
-
-class AIA::External::Subl < AIA::External::Tool
-  def initialize
-    super
-    @role     = :editor
-    @desc     = "Sublime Text Editor"
-    @url      = "https://www.sublimetext.com/"
-    @install  = "echo 'Download from website'"
+# lib/aia/tools/subl.rb
+
+class AIA::Subl < AIA::Tools
+
+  meta(
+    name:     'subl',
+    role:     :editor,
+    desc:     "Sublime Text Editor",
+    url:      "https://www.sublimetext.com/",
+    install:  "echo 'Download from website'",
+  )
+
+
+  DEFAULT_PARAMETERS = [
+    "--new-window",   # Open a new window
+    "--wait",         # Wait for the files to be closed before returning
+  ].join(' ')
+  
+  attr_accessor :command
+
+
+  def initialize(file: "")
+    @file     = file
+
+    build_command
+  end
+
+
+  def build_command
+    @command = "#{meta.name} #{DEFAULT_PARAMETERS} #{@file}"
   end
 
   
-  def open(file)
-    `#{name} #{file}`
+  def run
+    `#{command}`
   end
 end
 

data/lib/aia/tools/temp.md

@@ -0,0 +1,97 @@
+# lib/aia/tools.rb
+
+```ruby
+require 'hashie'
+
+module AIA
+  class Tools
+    @subclasses = {}
+
+    class << self
+      attr_reader :subclasses, :metadata
+
+      def inherited(subclass)
+        @subclasses[subclass.name.split('::').last.downcase] = subclass
+        subclass.instance_variable_set(:@metadata, Jashie::Mash.new)
+      end
+
+      def meta
+        @metadata ||= Jashie::Mash.new
+      end
+
+      def define_metadata(&block)
+        meta.instance_eval(&block)
+      end
+
+      def search_for(name: nil, role: nil)
+        return subclasses[name.downcase] if name
+        return subclasses.values.select { |subclass| subclass.meta.role == role } if role
+      end
+    end
+
+    def self.method_missing(name, *args, &block)
+      @metadata.public_send(name, *args, &block)
+    end
+
+    def self.respond_to_missing?(method_name, include_private = false)
+      @metadata.respond_to?(method_name) || super
+    end
+  end
+end
+```
+
+# lib/aia/tools/mods.rb
+
+```ruby
+require_relative 'tools'
+
+module AIA
+  class Mods < Tools
+    DEFAULT_PARAMETERS = "--no-limit".freeze
+
+    attr_accessor :command, :extra_options, :text, :files
+
+    define_metadata do
+      role :backend
+      desc 'AI on the command-line'
+      url  'https://github.com/charmbracelet/mods'
+    end
+
+    def initialize(extra_options: "", text: "", files: [])
+      @extra_options = extra_options
+      @text = text
+      @files = files
+      build_command
+    end
+
+    def build_command
+      parameters = DEFAULT_PARAMETERS.dup + " "
+      parameters += "-f " if ::AIA.config.markdown?
+      parameters += "-m #{AIA.config.model} " if ::AIA.config.model
+      parameters += @extra_options
+      @command = "mods #{parameters}"
+      @command += %Q["#{@text}"]
+
+      @files.each { |f| @command += " < #{f}" }
+
+      @command
+    end
+
+    def run
+      `#{@command}`
+    end
+  end
+end
+```
+
+```ruby
+# Example usage:
+# mods_class = AIA::Tools.search_for(name: 'mods')
+# mods_instance = mods_class.new(text: "Hello, mods!")
+# result = mods_instance.run
+
+# backend_tools = AIA::Tools.search_for(role: :backend)
+```
+
+Note: The `Jashie::Mash` class is assumed to behave like `Hashie::Mash` (or similar) in providing a flexible object for storing metadata. You'll need to define `Jashie::Mash` or import a library that provides a similar functionality to match this example.
+

data/lib/aia/tools/vim.rb

@@ -0,0 +1,93 @@
+# lib/aia/tools/vim.rb
+
+class AIA::Vim < AIA::Tools
+
+  meta(
+    name:     'vim',
+    role:     :editor,
+    desc:     "Vi IMproved (VIM)",
+    url:      "https://www.vim.org",
+    install:  "brew install vim",
+  )
+
+  DEFAULT_PARAMETERS = [
+    " ", # no parameters 
+  ].join(' ')
+  
+  attr_accessor :command
+
+
+  def initialize(file: "")
+    @file     = file
+
+    build_command
+  end
+
+
+  def build_command
+    @command = "#{meta.name} #{DEFAULT_PARAMETERS} #{@file}"
+  end
+
+  
+  def run
+    # Using 'system' instead of backticks becuase
+    # with the back ticks vim was complaining that it
+    # was not connected to a terminal.
+    system command
+  end
+end
+
+__END__
+
+VIM - Vi IMproved 9.0 (2022 Jun 28, compiled Sep 30 2023 05:45:56)
+
+Usage: vim [arguments] [file ..]       edit specified file(s)
+   or: vim [arguments] -               read text from stdin
+   or: vim [arguments] -t tag          edit file where tag is defined
+   or: vim [arguments] -q [errorfile]  edit file with first error
+
+Arguments:
+   --			Only file names after this
+   -v			Vi mode (like "vi")
+   -e			Ex mode (like "ex")
+   -E			Improved Ex mode
+   -s			Silent (batch) mode (only for "ex")
+   -d			Diff mode (like "vimdiff")
+   -y			Easy mode (like "evim", modeless)
+   -R			Readonly mode (like "view")
+   -Z			Restricted mode (like "rvim")
+   -m			Modifications (writing files) not allowed
+   -M			Modifications in text not allowed
+   -b			Binary mode
+   -l			Lisp mode
+   -C			Compatible with Vi: 'compatible'
+   -N			Not fully Vi compatible: 'nocompatible'
+   -V[N][fname]		Be verbose [level N] [log messages to fname]
+   -D			Debugging mode
+   -n			No swap file, use memory only
+   -r			List swap files and exit
+   -r (with file name)	Recover crashed session
+   -L			Same as -r
+   -T <terminal>	Set terminal type to <terminal>
+   --not-a-term		Skip warning for input/output not being a terminal
+   --ttyfail		Exit if input or output is not a terminal
+   -u <vimrc>		Use <vimrc> instead of any .vimrc
+   --noplugin		Don't load plugin scripts
+   -p[N]		Open N tab pages (default: one for each file)
+   -o[N]		Open N windows (default: one for each file)
+   -O[N]		Like -o but split vertically
+   +			Start at end of file
+   +<lnum>		Start at line <lnum>
+   --cmd <command>	Execute <command> before loading any vimrc file
+   -c <command>		Execute <command> after loading the first file
+   -S <session>		Source file <session> after loading the first file
+   -s <scriptin>	Read Normal mode commands from file <scriptin>
+   -w <scriptout>	Append all typed commands to file <scriptout>
+   -W <scriptout>	Write all typed commands to file <scriptout>
+   -x			Edit encrypted files
+   --startuptime <file>	Write startup timing messages to <file>
+   --log <file>		Start logging to <file> early
+   -i <viminfo>		Use <viminfo> instead of .viminfo
+   --clean		'nocompatible', Vim defaults, no plugins, no viminfo
+   -h  or  --help	Print Help (this message) and exit
+   --version		Print version information and exit