prompt_manager 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e3ba20b4c51adf033fc6124346bbb568be751fb3820000773dd51b496c6bc64
-  data.tar.gz: 950e2dd314ac1eec127c6ea3887ddd727fc55b6b5bb5735cac32c175de4135e5
+  metadata.gz: 2772d50f835a71c26631b2109af906008fec84b62e7ccf435a188fb856415268
+  data.tar.gz: c1aa3889826246a79df35ad74cd221c1374af161083a34f50d64ef09f5606ade
 SHA512:
-  metadata.gz: 1dc004fae9eba3c212014102a89897a0a7301e3157efd6b662e75766e387b057110c58556f918c97dc729edf4968963245d86736a1b8e80795fc7258620eacc2
-  data.tar.gz: ce46bbfa158650fabfa9741f3b3b9ab42e4acf6022d6dedbd62b377f9659dab72d9ed241ba575c489b6fabab6f550af03a5afa4fc9074303b866c96984f3d769
+  metadata.gz: c43cc115f2dfa8e847c499386b482d29f3454ca068b0d161d8c14350002d955461962e1009af0a932a92388eef39b134515bca6f694dabd41110150301339b56
+  data.tar.gz: 55b0e4f827d1950f39ad87909954660cb5ae0f6da44a4de0b43aad637dc1d99d878d2cb1876ac4a001cd42c190e1160a76593c6f4cba3b8411c250bd42e97e35

data/CHANGELOG.md

@@ -2,4 +2,4 @@
 
 ## [0.1.0] - 2023-11-16
 
-- Initial release
+- Initial release using the FileSystemAdapter

data/README.md

@@ -1,99 +1,69 @@
 # PromptManager
 
-**Under Development**
+Manage the parameterized prompts (text) used in generative AI (aka chatGPT, OpenAI, _et.al._) using storage adapters such as FileSystemAdapter, SqliteAdapter and ActiveRecordAdapter.
 
-Extracting the prompt management functionality fro the aip.rb file into a new gem that will provide a generic management service for other programs.
-
-## AIP.RB Legacy Summary of Capability
-
-This is just some source material for later documentation.
-
-### README for aip.rb
-
-#### Overview
-
-The `aip.rb` Ruby script is a command-line interface (CLI) tool designed to leverage generative AI with saved parameterized prompts. It integrates with the `mods` command-line tool that uses a GPT-based model to generate responses based on user-provided prompts. The script offers an array of features that make interacting with AI models more convenient and streamlined. 
-
-#### Features
-
-- **Prompt Management**
-  - Users can select prompts from a saved collection with the help of command-line searching and filtering.
-  - Prompts can be edited by the user to better fit their specific context or requirement.
-  - Support for reading input from files to provide context for AI generation is included.
-  
-- **AI Integration**
-  - The script interacts with `mods`, a generative AI utilizing GPT-based models, to produce outputs from the prompts.
-  
-- **Output Handling**
-  - Generated content is saved to a specified file for record-keeping and further use.
-  
-- **Activity Logging**
-  - All actions, including prompt usage and AI output, are logged with timestamps for review and auditing purposes.
-
-#### Dependencies
+## Installation
 
-The script requires the installation of the following command-line tools:
+Install the gem and add to the application's Gemfile by executing:
 
-- `fzf`: a powerful command-line fuzzy finder.
-- `mods`: an AI-powered CLI tool for generative AI interactions.
-- `the_silver_searcher (ag)`: a code-searching tool similar to ack and used for searching prompts.
+    bundle add prompt_manager
 
-#### Usage
+If bundler is not being used to manage dependencies, install the gem by executing:
 
-The `aip.rb` script offers a set of command-line options to guide the interaction with AI:
+    gem install prompt_manager
 
-- `-p, --prompt`: Specify the prompt name to be used.
-- `-e, --edit`: Open the prompt text for editing before generation.
-- `-f, --fuzzy`: Allows fuzzy matching for prompt selection.
-- `-o, --output`: Sets the output file for the generated content.
+## Usage
 
-Additional flags and options can be passed to the `mods` tool by appending them after a `--` separator.
+See [examples/simple.rb](examples.simple.rb)
 
-#### Installation
+## Overview
 
-Before using the script, one must ensure the required command-line tools (`fzf`, `mods`, and `the_silver_searcher`) are installed, and the Ruby environment is correctly set up with the necessary gems.
+### Generative AI (gen-AI)
 
-#### Development Notes
+Gen-AI deals with the conversion (some would say execution) of a human natural language text (the "prompt") into somthing else using what are known as large language models (LLM) such as those available from OpenAI.  A parameterized prompt is one in whcih there are embedded keywords (parameters) which are place holders for other text to be inserted into the prompt.
 
-The author suggests that the script has matured enough to be converted into a Ruby gem for easier distribution and installation.
+The prompt_manager uses a regurlar expression to identify these keywords within the prompt.  It uses the keywords as keys in a `parameters` Hash which is stored with the prompt text in a serialized form - for example as JSON.
 
-#### Getting Help
+#### What does a keyword look like?
 
-For help with using the CLI tool or further understanding the `mods` command, users can refer to the AI CLI Program help section included in the script or by invoking the `--help` flag.
+The current hard-coded REGEX for a [KEYWORD] identifies any all [UPPERCASE_TEXT] enclosed in squal brackes as a keyword.  [KEY WORDS CAN ALSO HAVE SPACES] as well as the underscore character.
 
-#### Conclusion
+This is just the initial convention adopted by prompt_manager.  It is intended that this REGEX be configurable so that the promp_manager can be used with other conventions.
 
-The `aip.rb` script is designed to offer a user-friendly and flexible approach to integrating generative AI into content creation processes. It streamlines the interactions and management of AI-generated content by providing prompt management, AI integration, and logging capabilities, packaged inside a simple command-line utility.
+### Storage Adapters
 
+A storage adapter is a class instance that ties the `PromptManager::Prompt` class to a storage facility that holds the actual prompts.  Currentlyt there are 3 storage adapters planned for implementation.
 
+#### FileSystemAdapter
 
+This is the first storage adapter developed.  It saves prompts as text files within the file system inside a designated `prompts_dir` (directory) such as `~/,prompts` or where it makes the most sense to you.  Another example would be to have your directory on a shared file system so that others can use the same prompts.
 
+The `promp ID` is the basename of the text file.  For example `todo.txt` is the file for the prompt ID `todo` (see the examples directory.)
 
-## Installation
+The parameters for the `todo` prompt ID are saved in the same directory as `todo.txt` in a JSON file named `todo.json` (also in the examples directory.)
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+#### SqliteAdapter
 
-Install the gem and add to the application's Gemfile by executing:
+TODO: This may be the next adapter to be implemented.
 
-    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+#### ActiveRecordAdapter
 
-If bundler is not being used to manage dependencies, install the gem by executing:
+TODO: Still looking for requirements on how to integrate with an existing `rails` app.  Looking for ideas.
 
-    $ gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+#### Other Potential Storage Adapters
 
-## Usage
+There are many possibilities to example this plugin concept of the storage adapter.  Here are some for consideration:
 
-TODO: Write usage instructions here
+* RedisAdapter - Not sure; isn't redis more temporary oriented?
+* ApiAdapter - use some end-point to CRUD a prompt
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+Looking for feedback and contributors to enhance the capability of prompt_manager.
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/prompt_manager.
+Bug reports and pull requests are welcome on GitHub at https://github.com/MadBomber/prompt_manager.
 
 ## License
 

data/Rakefile

@@ -6,7 +6,7 @@ require "rake/testtask"
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
   t.libs << "lib"
-  t.test_files = FileList["test/**/test_*.rb"]
+  t.test_files = FileList["test/**/*_test.rb"]
 end
 
 task default: :test

data/examples/prompts_dir/todo.json

@@ -0,0 +1 @@
+{"[LANGUAGE]":"ruby"}

data/examples/prompts_dir/todo.txt

@@ -0,0 +1,7 @@
+# prompts_dir/todo.txt
+# Desc: Let the robot fix the TODO items.
+#
+
+As an experienced [LANGUAGE] software engineer write some [LANGUAGE] source code. Consider the following [LANGUAGE] file.  For each comment line that contains the word "[KEYWORD_AKA_TODO]" take the text that follows that word as a requirement to be implemented in [LANGUAGE].  Remove the "[KEYWORD_AKA_TODO]" word from the comment line.  After the line insert the [LANGUAGE] code that implements the requirement.
+
+__END__

data/examples/simple.rb

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# frozen_string_literal: true
+# warn_indent: true
+##########################################################
+###
+##  File: simple.rb
+##  Desc: Simple demo of the PromptManager and FileStorageAdapter
+##  By:   Dewayne VanHoozer (dvanhoozer@gmail.com)
+##
+#
+
+
+require 'prompt_manager'
+require 'prompt_manager/storage/file_system_adapter'
+
+require 'amazing_print'
+require 'pathname'
+
+HERE        = Pathname.new( __dir__ )
+PROMPTS_DIR = HERE + "prompts_dir"
+
+
+######################################################
+# Main
+
+at_exit do
+  puts
+  puts "Done."
+  puts
+end
+
+# Configure the Storage Adapter to use
+
+PromptManager::Prompt.storage_adapter = 
+  PromptManager::Storage::FileSystemAdapter.new(
+    prompts_dir: PROMPTS_DIR
+  )
+
+# Get a prompt
+
+todo = PromptManager::Prompt.get(id: 'todo')
+
+# This sequence simulates presenting each of the previously
+# used values for each keyword to the user to accept or
+# edit.
+
+# ap todo.keywords
+
+# This is a new keyword that was added after the current
+# todo.json file was created.  Simulate the user setting
+# its value.
+
+todo.parameters["[KEYWORD_AKA_TODO]"] = "TODO"
+
+# When the parameter values change, the prompt must 
+# must be rebuilt using the build method.
+
+todo.build 
+
+
+puts <<~EOS
+  
+  Raw Text from Prompt File
+  includes all lines
+  =========================
+EOS
+
+puts todo.text
+
+
+puts <<~EOS
+  
+  Last Set of Parameters Used
+  Includes those recently added
+  =============================
+EOS
+
+ap todo.parameters
+
+
+puts <<~EOS
+  
+  Prompt Ready to Send to gen-AI
+  ==============================
+EOS
+
+puts todo.to_s
+

data/lib/prompt_manager/prompt.rb

@@ -0,0 +1,151 @@
+# prompt_manager/lib/prompt_manager/prompt.rb
+
+# This class is responsible for managing prompts which can be utilized by
+# generative AI processes. This includes creation, retrieval, storage management,
+# as well as building prompts with replacement of parameterized values and 
+# comment removal. It communicates with a storage system through a storage 
+# adapter.
+
+class PromptManager::Prompt
+  PARAMETER_REGEX   = /(\[[A-Z _|]+\])/ # NOTE: old from aip.rb
+  @storage_adapter  = nil
+
+  class << self
+    attr_accessor :storage_adapter
+
+    alias_method :get, :new
+
+    def create(id:, text: "", parameters: {})
+      storage_adapter.save(
+        id:         id,
+        text:       text,
+        parameters: parameters
+      )
+
+      new(id: id)
+    end
+
+    def search(for_what)
+      storage_adapter.search(for_what)
+    end
+  end
+  
+  # SMELL:  Does the db (aka storage adapter) really need
+  #         to be accessible by the main program?
+  attr_accessor :db, :id, :text, :parameters, :keywords
+  
+
+  # Retrieve the specific prompt ID from the Storage system.
+  def initialize(
+      id:       nil,  # A String name for the prompt
+      context:  []    # FIXME: Array of Strings or Pathname?
+    )
+
+    @id  = id
+    @db  = self.class.storage_adapter
+    
+    validate_arguments(@id, @db)
+
+    @record     = db.get(id: id)
+    @text       = @record[:text]
+    @parameters = @record[:parameters]
+    @keywords   = []
+
+    update_keywords
+    build
+  end
+
+
+  # Make sure the ID and DB are good-to-go
+  def validate_arguments(prompt_id, prompts_db)
+    raise ArgumentError, 'id cannot be blank'           if prompt_id.nil? || id.strip.empty?
+    raise(ArgumentError, 'storage_adapter is not set')  if prompts_db.nil?
+  end
+
+
+  # Return tje prompt text suitable for passing to a
+  # gen-AI process.
+  def to_s
+    @prompt
+  end
+
+
+  # Save the prompt to the Storage system
+  def save
+    db.save(
+      id:         id, 
+      text:       text, 
+      parameters: parameters
+    )    
+  end
+
+
+  # Delete this prompt from the Storage system
+  def delete
+    db.delete(id: id)  
+  end
+
+
+  # Build the @prompt String by replacing the keywords
+  # with there parameterized values and removing all
+  # the comments.
+  #  
+  def build
+    @prompt = text.gsub(PARAMETER_REGEX) do |match|
+                param_name = match
+                parameters[param_name] || match
+              end
+
+    remove_comments
+  end
+
+  ######################################
+  private
+
+  def update_keywords
+    @keywords = @text.scan(PARAMETER_REGEX).flatten.uniq
+    keywords.each do |kw|
+      @parameters[kw] = "" unless @parameters.has_key?(kw)
+    end
+  end
+
+
+  def remove_comments
+    lines           = @prompt
+                        .split("\n")
+                        .reject{|a_line| a_line.strip.start_with?('#')}
+
+    # Remove empty lines at the start of the prompt
+    #
+    lines = lines.drop_while(&:empty?)
+
+    # Drop all the lines at __END__ and after
+    #
+    logical_end_inx = lines.index("__END__")
+
+    @prompt = if logical_end_inx
+                lines[0...logical_end_inx] # NOTE: ... means to not include last index
+              else
+                lines
+              end.join("\n") 
+  end
+  
+
+  # Handle storage errors
+  # SMELL:  Just raise them or get out of their way and let the
+  #         main program do tje job.
+  def handle_storage_error(error)
+    # Log the error message, notify, or take appropriate action
+    log_error("Storage operation failed: #{error.message}")
+    # Re-raise the error if necessary, or define recovery steps
+    raise error
+  end
+
+
+  # SMELL:  should this gem log errors or is that a function of
+  #         main program?  I believe its the main program's job.
+  def log_error(message)
+    puts "ERROR: #{message}"
+  end
+end
+

data/lib/prompt_manager/storage/active_record_adapter.rb

@@ -0,0 +1,66 @@
+# prompt_manager/lib/prompt_manager/storage/active_record_adapter.rb
+
+require 'active_record'
+
+# TODO: Will need a database.yml file
+#       will need to know the column names that coorespond
+#       with the things that the Prompt class wants.
+
+class PromptManager::Storage::ActiveRecordAdapter
+  attr_reader :model_class
+
+  def initialize(model_class)
+    @model_class = model_class
+  end
+
+
+  def prompt_text(prompt_id)
+    prompt = find_prompt(prompt_id)
+    prompt.text
+  end
+
+
+  def parameter_values(prompt_id)
+    prompt = find_prompt(prompt_id)
+    JSON.parse(prompt.params, symbolize_names: true)
+  end
+
+
+  def save(prompt_id, prompt_text, parameter_values)
+    prompt        = model_class.find_or_initialize_by(id: prompt_id)
+    prompt.text   = prompt_text
+    prompt.params = parameter_values.to_json
+    prompt.save!
+  end
+
+
+  def delete(prompt_id)
+    prompt = find_prompt(prompt_id)
+    prompt.destroy
+  end
+
+
+  def search(for_what)
+    # TODO: search through all prompts. Return an Array of
+    #       prompt_id where the text of the prompt contains
+    #       for_what is being searched.
+
+    []
+  end
+
+
+  class << self
+    def config
+      # TODO: establish a connection to the database
+      #       maybe define the prompts table and its
+      #       columns of interest.
+    end
+  end
+
+  ###############################################
+  private
+
+  def find_prompt(prompt_id)
+    model_class.find_by(id: prompt_id) || raise('Prompt not found')
+  end
+end

data/lib/prompt_manager/storage/file_system_adapter.rb

@@ -0,0 +1,149 @@
+# prompt_manager/lib/prompt_manager/storage/file_system_adapter.rb
+
+
+require 'json'
+
+class PromptManager::Storage::FileSystemAdapter
+  PARAMS_EXTENSION = '.json'.freeze
+  PROMPT_EXTENSION = '.txt'.freeze
+
+  attr_reader :prompts_dir
+
+  def initialize(
+      prompts_dir:  '.prompts',
+      search_proc:  nil   # Example: ->(q) {`ag -l #{q}`}
+    )
+
+    # validate that prompts_dir exist and is in fact a directory.
+    unless Dir.exist?(prompts_dir)
+      raise "Directory #{prompts_dir} does not exist or is not a directory"
+    end
+
+    @prompts_dir  = prompts_dir
+    @search_proc  = search_proc
+  end
+
+
+  def get(id:)
+    validate_id(id)
+
+    {
+      id:         id,
+      text:       prompt_text(id),
+      parameters: parameter_values(id)
+    }
+  end
+
+
+  # Retrieve prompt text by its id
+  def prompt_text(prompt_id)
+    read_file(file_path(prompt_id, PROMPT_EXTENSION))
+  end
+
+
+  # Retrieve parameter values by its id
+  def parameter_values(prompt_id)
+    json_content = read_file(file_path(prompt_id, PARAMS_EXTENSION))
+    deserialize(json_content)
+  end
+
+
+  # Save prompt text and parameter values to corresponding files
+  def save(
+      id:, 
+      text: "", 
+      parameters: {}
+    )
+    validate_id(id)
+
+    prompt_filepath = file_path(id, PROMPT_EXTENSION)
+    params_filepath = file_path(id, PARAMS_EXTENSION)
+    
+    write_with_error_handling(prompt_filepath, text)
+    write_with_error_handling(params_filepath, serialize(parameters))
+  end
+
+
+  # Delete prompted text and parameter values files
+  def delete(id:)
+    validate_id(id)
+
+    prompt_filepath = file_path(id, PROMPT_EXTENSION)
+    params_filepath = file_path(id, PARAMS_EXTENSION)
+    
+    delete_with_error_handling(prompt_filepath)
+    delete_with_error_handling(params_filepath)
+  end
+
+
+  def search(for_what)
+    if @search_proc
+      @search_proc.call(for_what)
+    else
+      search_prompts(for_what)
+    end
+  end
+
+
+  ##########################################
+  private
+
+  def validate_id(id)
+    raise ArgumentError, 'Invalid ID format' unless id =~ /^[a-zA-Z0-9\-_]+$/
+  end
+
+
+  def write_with_error_handling(file_path, content)
+    begin
+      File.write(file_path, content)
+    rescue IOError => e
+      raise "Failed to write to file: #{e.message}"
+    end
+  end
+
+
+  def delete_with_error_handling(file_path)
+    begin
+      FileUtils.rm_f(file_path)
+    rescue IOError => e
+      raise "Failed to delete file: #{e.message}"
+    end
+  end
+
+
+  def file_path(id, extension)
+    File.join(@prompts_dir, "#{id}#{extension}")
+  end
+
+
+  def read_file(full_path)
+    raise IOError, 'File does not exist' unless File.exist?(full_path)
+    File.read(full_path)
+  end
+
+
+  def search_prompts(search_term)
+    query_term = search_term.downcase
+
+    Dir.glob(File.join(@prompts_dir, "*#{PROMPT_EXTENSION}")).each_with_object([]) do |file_path, ids|
+      File.open(file_path) do |file|
+        file.each_line do |line|
+          if line.downcase.include?(query_term)
+            ids << File.basename(file_path, PROMPT_EXTENSION)
+            next
+          end
+        end
+      end
+    end.uniq
+  end
+
+
+  def serialize(data)
+    data.to_json
+  end
+
+
+  def deserialize(data)
+    JSON.parse(data)
+  end
+end

data/lib/prompt_manager/storage/sqlite_adapter.rb

@@ -0,0 +1,65 @@
+# prompt_manager/lib/prompt_manager/storage/sqlite_adapter.rb
+
+require 'json'
+require 'sqlite3'
+
+class PromptManager::Storage::SqliteAdapter
+  def initialize(db_path = 'prompts.db')
+    @db = SQLite3::Database.new(db_path)
+    create_tables
+  end
+
+  def save_prompt(prompt_id, text, params)
+    @db.execute("INSERT INTO prompts (id, text, params) VALUES (?, ?, ?)",
+                [prompt_id, text, params.to_json])
+  end
+
+  def prompt_text(prompt_id)
+    result = @db.get_first_value("SELECT text FROM prompts WHERE id = ?", [prompt_id])
+    raise 'Prompt not found' if result.nil?
+    result
+  end
+
+  def parameter_values(prompt_id)
+    json_content = @db.get_first_value("SELECT params FROM prompts WHERE id = ?", [prompt_id])
+    raise 'Parameters not found' if json_content.nil?
+    JSON.parse(json_content, symbolize_names: true)
+  end
+
+  def save(prompt_id, prompt_text, parameter_values)
+    @db.execute(
+      'REPLACE INTO prompts (id, text, params) VALUES (?, ?, ?)',
+      [prompt_id, prompt_text, parameter_values.to_json]
+    )
+  end
+
+  def delete(prompt_id)
+    @db.execute('DELETE FROM prompts WHERE id = ?', [prompt_id])
+  end
+
+
+  def search(for_what)
+    # TODO: search through all prompts. Return an Array of
+    #       prompt_id where the text of the prompt contains
+    #       for_what is being searched.
+
+    []
+  end
+
+  ###################################################
+  private
+
+  def create_tables
+    @db.execute <<-SQL
+      CREATE TABLE IF NOT EXISTS prompts (
+        id TEXT PRIMARY KEY,
+        text TEXT NOT NULL,
+        params TEXT NOT NULL
+      );
+    SQL
+  end
+end
+
+
+
+

data/lib/prompt_manager/storage.rb

@@ -0,0 +1,7 @@
+# prompt_manager/lib/prompt_manager/storage.rb
+
+module PromptManager
+  module Storage
+  end
+end
+

data/lib/prompt_manager/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PromptManager
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/prompt_manager.rb

@@ -1,8 +1,12 @@
+# prompt_manager/lib/prompt_manager.rb
+#
 # frozen_string_literal: true
 
 require_relative "prompt_manager/version"
+require_relative "prompt_manager/storage"
+require_relative "prompt_manager/prompt"
 
 module PromptManager
   class Error < StandardError; end
-  # Your code goes here...
+  # TODO: Add some more module specific errors here
 end

metadata

@@ -1,16 +1,60 @@
 --- !ruby/object:Gem::Specification
 name: prompt_manager
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Dewayne VanHoozer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-16 00:00:00.000000000 Z
-dependencies: []
-description: Manage parameterized prompt text for use with GPT/LLM
+date: 2023-11-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: amazing_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fakefs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: "Manage the parameterized prompts (text) used in generative AI (aka chatGPT,
+  \npen AI, et.al.) using storage adapters such as FileSystemAdapter, \nSqliteAdapter
+  and ActiveRecordAdapter.\n"
 email:
 - dvanhoozer@gmail.com
 executables: []
@@ -23,10 +67,16 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- lib/aip.rb
+- examples/prompts_dir/todo.json
+- examples/prompts_dir/todo.txt
+- examples/simple.rb
 - lib/prompt_manager.rb
+- lib/prompt_manager/prompt.rb
+- lib/prompt_manager/storage.rb
+- lib/prompt_manager/storage/active_record_adapter.rb
+- lib/prompt_manager/storage/file_system_adapter.rb
+- lib/prompt_manager/storage/sqlite_adapter.rb
 - lib/prompt_manager/version.rb
-- lib/temp.md
 homepage: https://github.com/MadBomber/prompt_manager
 licenses:
 - MIT
@@ -50,8 +100,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.0.dev
+rubygems_version: 3.4.22
 signing_key:
 specification_version: 4
-summary: Manage prompts for use with chatGPT LLMs
+summary: Manage prompts for use with gen-AI processes
 test_files: []

data/lib/aip.rb

@@ -1,402 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-# frozen_string_literal: true
-# warn_indent: true
-##########################################################
-###
-##  File: aip.rb
-##  Desc: Use generative AI with saved parameterized prompts
-##  By:   Dewayne VanHoozer (dvanhoozer@gmail.com)
-##
-##  This program makes use of the gem word_wrap's
-##  CLI tool: ww
-#
-
-
-=begin
-
-brew install fzf mods the_silver_searcher
-
-fzf                  Command-line fuzzy finder written in Go
-                     |__ https://github.com/junegunn/fzf
-
-mods                 AI on the command-line
-                     |__ https://github.com/charmbracelet/mods
-
-the_silver_searcher  Code-search similar to ack
-                     |__ https://github.com/ggreer/the_silver_searcher
-
-Program Summary
-
-The program is a Ruby script that integrates with the `mods` CLI tool, which is built on a GPT-based generative AI model. This script is designed to make use of generative AI through a set of saved, parameterized prompts. Users can easily interact with the following features:
-
-- **Prompt Selection**: Users have the ability to choose a prompt from a curated list. This selection process is streamlined by allowing users to search and filter prompts using keywords.
-
-- **Prompt Editing**: There is functionality for a user to modify the text of an existing prompt, tailoring it to better meet their specific needs.
-
-- **File Input**: The script can read in data from input files, providing the necessary context or information required for the AI to generate relevant content.
-
-- **AI Integration**: Utilizing the `mods` GPT-based CLI tool, the script takes the chosen edited prompt to guide the AI in generating its output.
-
-- **Output Management**: After the generative process, the resulting output is saved to a designated file, ensuring that the user has a record of the AI's creations.
-
-- **Logging**: For tracking and accountability, the program records the details of each session, including the prompt used, the AI-generated output, and the precise timestamp when the generation occurred.
-
-This robust tool is excellent for users who wish to harness the power of generative AI for creating content, with an efficient and user-friendly system for managing the creation process.
-
-=end
-
-#
-# TODO: I think this script has reached the point where
-#       it is ready to become a proper gem.
-#
-
-require 'pathname'
-HOME = Pathname.new( ENV['HOME'] )
-
-
-MODS_MODEL      = ENV['MODS_MODEL'] || 'gpt-4-1106-preview'
-
-AI_CLI_PROGRAM  = "mods"
-ai_default_opts = "-m #{MODS_MODEL} --no-limit -f"
-ai_options      = ai_default_opts.dup
-
-extra_inx       = ARGV.index('--')
-
-if extra_inx
-  ai_options += " " + ARGV[extra_inx+1..].join(' ')
-  ARGV.pop(ARGV.size - extra_inx)
-end
-
-AI_COMMAND        = "#{AI_CLI_PROGRAM} #{ai_options} "
-EDITOR            = ENV['EDITOR']
-PROMPT_DIR        = HOME + ".prompts"
-PROMPT_LOG        = PROMPT_DIR + "_prompts.log"
-PROMPT_EXTNAME    = ".txt"
-DEFAULTS_EXTNAME  = ".json"
-# SEARCH_COMMAND    = "ag -l"
-KEYWORD_REGEX     = /(\[[A-Z _|]+\])/
-
-AVAILABLE_PROMPTS = PROMPT_DIR
-                      .children
-                      .select{|c| PROMPT_EXTNAME == c.extname}
-                      .map{|c| c.basename.to_s.split('.')[0]}
-
-AVAILABLE_PROMPTS_HELP  = AVAILABLE_PROMPTS
-                            .map{|c| "  * " + c}
-                            .join("\n")
-
-require 'amazing_print'
-require 'json'
-require 'readline'    # TODO: or reline ??
-require 'word_wrap'
-require 'word_wrap/core_ext'
-
-
-require 'debug_me'
-include DebugMe
-
-require 'cli_helper'
-include CliHelper
-
-configatron.version = '1.1.0'
-
-AI_CLI_PROGRAM_HELP = `#{AI_CLI_PROGRAM} --help`
-
-HELP = <<EOHELP
-AI CLI Program
-==============
-
-The AI cli program being used is: #{AI_CLI_PROGRAM}
-
-The defaul options to #{AI_CLI_PROGRAM} are:
-  "#{ai_default_opts}"
-
-You can pass additional CLI options to #{AI_CLI_PROGRAM} like this:
-  "#{my_name} my options -- options for #{AI_CLI_PROGRAM}"
-
-#{AI_CLI_PROGRAM_HELP}
-
-EOHELP
-
-cli_helper("Use generative AI with saved parameterized prompts") do |o|
-
-  o.string  '-p', '--prompt', 'The prompt name',        default: ""
-  o.bool    '-e', '--edit',   'Edit the prompt text',   default: false
-  o.bool    '-f', '--fuzzy',   'Allow fuzzy matching',  default: false
-  o.path    '-o', '--output', 'The output file',        default: Pathname.pwd + "temp.md"
-end
-
-
-AG_COMMAND        = "ag --file-search-regex '\.txt$' e"
-CD_COMMAND        = "cd #{PROMPT_DIR}"
-FIND_COMMAND      = "find . -name '*.txt'"
-
-FZF_OPTIONS       = [
-  "--tabstop=2",  # 2 soaces for a tab
-  "--header='Prompt contents below'",
-  "--header-first",
-  "--prompt='Search term: '",
-  '--delimiter :',
-  "--preview 'ww {1}'",              # ww comes from the word_wrap gem
-  "--preview-window=down:50%:wrap"
-].join(' ')
-
-FZF_OPTIONS += "--exact" unless fuzzy?
-
-FZF_COMMAND       = "#{CD_COMMAND} ; #{FIND_COMMAND} | fzf #{FZF_OPTIONS}"
-AG_FZF_COMMAND    = "#{CD_COMMAND} ; #{AG_COMMAND}   | fzf #{FZF_OPTIONS}"
-
-# use `ag` ti build a list of text lines from each prompt
-# use `fzf` to search through that list to select a prompt file
-
-def ag_fzf = `#{AG_FZF_COMMAND}`.split(':')&.first&.strip&.gsub('.txt','')
-
-
-configatron.input_files = get_pathnames_from( configatron.arguments, %w[.rb .txt .md])
-
-
-# TODO: Make the use of the "-p" flag optional.
-#       I find myself many times forgetting to use it
-#       and this program rejecting it because
-#       "the file does not exist" thinging that it
-#       was an input file file rather than a prompt
-#       name.
-
-if configatron.prompt.empty?
-  configatron.prompt  = ag_fzf
-end
-
-unless edit?
-  if configatron.prompt.nil? || configatron.prompt.empty?
-    error "No prompt provided"
-  end
-end
-
-abort_if_errors
-
-configatron.prompt_path   = PROMPT_DIR + (configatron.prompt + PROMPT_EXTNAME)
-configatron.defaults_path = PROMPT_DIR + (configatron.prompt + DEFAULTS_EXTNAME)
-
-if  !configatron.prompt_path.exist? && !edit?
-  error "This prompt does not exist: #{configatron.prompt}\n"
-end
-
-configatron.prompt_path   = PROMPT_DIR + (configatron.prompt + PROMPT_EXTNAME)
-configatron.defaults_path = PROMPT_DIR + (configatron.prompt + DEFAULTS_EXTNAME)
-
-abort_if_errors
-
-if edit?
-  unless configatron.prompt_path.exist?
-    configatron.prompt_path.write <<~PROMPT
-      # #{configatron.prompt_path.relative_path_from(HOME)}
-      # DESC: 
-
-    PROMPT
-  end
-
-  `#{EDITOR} #{configatron.prompt_path}`
-end
-
-######################################################
-# Local methods
-
-def extract_raw_prompt
-  array_of_strings = ignore_after_end
-  print_header_comment(array_of_strings)
-
-  array_of_strings.reject do |a_line|
-                    a_line.chomp.strip.start_with?('#')
-                  end
-                  .join("\n")
-end
-
-
-def ignore_after_end
-  array_of_strings  = configatron.prompt_path.readlines
-                        .map{|a_line| a_line.chomp.strip}
-
-  x = array_of_strings.index("__END__")
-
-  unless x.nil?
-    array_of_strings = array_of_strings[..x-1]
-  end
-
-  array_of_strings
-end
-
-
-def print_header_comment(array_of_strings)
-  print "\n\n" if verbose?
-
-  x = 0
-
-  while array_of_strings[x].start_with?('#') do
-    puts array_of_strings[x]
-    x += 1
-  end
-
-  print "\n\n" if x>0 && verbose?
-end
-
-
-# Returns an Array of keywords or phrases that look like:
-#   [KEYWORD]
-#   [KEYWORD|KEYWORD]
-#   [KEY PHRASE]
-#   [KEY PHRASE | KEY PHRASE | KEY_WORD]
-#
-def extract_keywords_from(prompt_raw)
-  prompt_raw.scan(KEYWORD_REGEX).flatten.uniq
-end
-
-# get the replacements for the keywords
-def replacements_for(keywords)
-  replacements = load_default_replacements
-
-  keywords.each do |kw|
-    default = replacements[kw]
-    print "#{kw} (#{default}) ? "
-    a_string          = Readline.readline("\n> ", false)
-    replacements[kw]  = a_string unless a_string.empty?
-  end
-
-  save_default_replacements(replacements)
-
-  replacements
-end
-
-
-def load_default_replacements
-  if configatron.defaults_path.exist?
-    JSON.parse(configatron.defaults_path.read)
-  else
-    {}
-  end
-end
-
-
-def save_default_replacements(a_hash)
-  return if a_hash.empty?
-  defaults = a_hash.to_json
-  configatron.defaults_path.write defaults
-end
-
-# substitute the replacements for the keywords
-def replace_keywords_with replacements, prompt_raw
-  prompt = prompt_raw.dup
-
-  replacements.each_pair do |keyword, replacement|
-    prompt.gsub!(keyword, replacement)
-  end
-
-  prompt
-end
-
-
-def log(prompt_path, prompt_raw, answer)
-  f = File.open(PROMPT_LOG, "ab")
-
-  f.write <<~EOS
-    =======================================
-    == #{Time.now}
-    == #{prompt_path}
-
-    PROMPT: #{prompt_raw}
-
-    RESULT:
-    #{answer}
-
-  EOS
-end
-
-
-######################################################
-# Main
-
-at_exit do
-  puts
-  puts "Done."
-  puts
-end
-
-ap configatron.to_h  if debug?
-
-configatron.prompt_raw  = extract_raw_prompt
-
-puts
-puts "PROMPT:"
-puts configatron.prompt_raw.wrap
-puts
-
-
-keywords      = extract_keywords_from configatron.prompt_raw
-replacements  = replacements_for keywords
-
-prompt = replace_keywords_with replacements, configatron.prompt_raw
-ptompt = %Q{prompt}
-
-command = AI_COMMAND + '"' + prompt + '"'
-
-configatron.input_files.each do |input_file|
-  command += " < #{input_file}"
-end
-
-
-print "\n\n" if verbose? && !keywords.empty?
-
-if verbose?
-  puts "="*42
-  puts command
-  puts "="*42
-  print "\n\n"
-end
-
-result = `#{command}`
-
-configatron.output.write result
-
-log configatron.prompt_path, prompt, result
-
-
-__END__
-
-To specify a history and autocomplete options with the readline method in Ruby using the readline gem, you can follow these steps:
-
-1. **History** - To enable history functionality, create a Readline::HISTORY object:
-```ruby
-history = Readline::HISTORY
-```
-You can then use the `history` object to add and manipulate history entries.
-
-2. **Autocomplete** - To enable autocomplete functionality, you need to provide a completion proc to `Readline.completion_proc`:
-```ruby
-Readline.completion_proc = proc { |input|  ... }
-```
-You should replace `...` with the logic for determining the autocomplete options based on the input.
-
-For example, you can define a method that provides autocomplete options based on a predefined array:
-```ruby
-def autocomplete_options(input)
-  available_options = ['apple', 'banana', 'cherry']
-  available_options.grep(/^#{Regexp.escape(input)}/)
-end
-
-Readline.completion_proc = proc { |input| autocomplete_options(input) }
-```
-
-In this example, the `autocomplete_options` method takes the user's input and uses the `grep` method to filter the available options based on the input prefix.
-
-Remember to require the readline gem before using these features:
-```ruby
-require 'readline'
-```
-
-With the above steps in place, you can use the readline method in your code, and the specified history and autocomplete options will be available.
-
-Note: Keep in mind that autocomplete options will only appear when tab is pressed while entering input.
-
-
-
-

data/lib/temp.md

@@ -1,57 +0,0 @@
-### README for aip.rb Ruby Script
-
-#### Overview
-
-The `aip.rb` Ruby script is a command-line interface (CLI) tool designed to leverage generative AI with saved parameterized prompts. It integrates with the `mods` command-line tool that uses a GPT-based model to generate responses based on user-provided prompts. The script offers an array of features that make interacting with AI models more convenient and streamlined. 
-
-#### Features
-
-- **Prompt Management**
-  - Users can select prompts from a saved collection with the help of command-line searching and filtering.
-  - Prompts can be edited by the user to better fit their specific context or requirement.
-  - Support for reading input from files to provide context for AI generation is included.
-  
-- **AI Integration**
-  - The script interacts with `mods`, a generative AI utilizing GPT-based models, to produce outputs from the prompts.
-  
-- **Output Handling**
-  - Generated content is saved to a specified file for record-keeping and further use.
-  
-- **Activity Logging**
-  - All actions, including prompt usage and AI output, are logged with timestamps for review and auditing purposes.
-
-#### Dependencies
-
-The script requires the installation of the following command-line tools:
-
-- `fzf`: a powerful command-line fuzzy finder.
-- `mods`: an AI-powered CLI tool for generative AI interactions.
-- `the_silver_searcher (ag)`: a code-searching tool similar to ack and used for searching prompts.
-
-#### Usage
-
-The `aip.rb` script offers a set of command-line options to guide the interaction with AI:
-
-- `-p, --prompt`: Specify the prompt name to be used.
-- `-e, --edit`: Open the prompt text for editing before generation.
-- `-f, --fuzzy`: Allows fuzzy matching for prompt selection.
-- `-o, --output`: Sets the output file for the generated content.
-
-Additional flags and options can be passed to the `mods` tool by appending them after a `--` separator.
-
-#### Installation
-
-Before using the script, one must ensure the required command-line tools (`fzf`, `mods`, and `the_silver_searcher`) are installed, and the Ruby environment is correctly set up with the necessary gems.
-
-#### Development Notes
-
-The author suggests that the script has matured enough to be converted into a Ruby gem for easier distribution and installation.
-
-#### Getting Help
-
-For help with using the CLI tool or further understanding the `mods` command, users can refer to the AI CLI Program help section included in the script or by invoking the `--help` flag.
-
-#### Conclusion
-
-The `aip.rb` script is designed to offer a user-friendly and flexible approach to integrating generative AI into content creation processes. It streamlines the interactions and management of AI-generated content by providing prompt management, AI integration, and logging capabilities, packaged inside a simple command-line utility.
-