pear-programmer 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5ff1857eefc3d9eb63642ff07a42536cec791067bbcaa27884586f37d8e3d1bb
+  data.tar.gz: 9639755ec441aa4ef3dca87d75dc71c742002386e275a4c406ba827269baf00e
+SHA512:
+  metadata.gz: 65b97022ce92f9504703082db00c511eb94d8936e8cd1ce8b75c55c2e80aa70a55168cda8afed36458213ded9689e35f5ac66c841d845730f6ff6fc9fc9240f1
+  data.tar.gz: 9c59045e0bc0a77e6a5190fa5836720b9a5bd8ec7e330c7a84676015933aab9e362bb8ad9a3b84cfc5a14e225e75e305eb587884fa994e487e73b9789e72e9fd

data/bin/pear-on

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require_relative '../lib/cli'

data/lib/cli/actions.rb

@@ -0,0 +1,224 @@
+require_relative "../pairprogrammer"
+require_relative "display"
+require_relative "version"
+# need to require file
+
+# TODO VALIDATIONS
+module Cli
+    class Actions
+        def self.init
+            Cli::Display.info_message("Welcome to Pear Programmer!")
+            confirmation = Cli::Display.confirmation("Are you in the root directory of your project?")
+            if !confirmation
+                Cli::Display.error_message("Please change directory into the root of your project and try again.")
+                return
+            end
+                
+            Cli::Display.info_message("creating #{Cli::Configuration::FILE_NAME} in #{Dir.pwd}")
+            Cli::Display.info_message("Context is any information about your project that you want the large language model to know about. A few sentences should suffice.")
+            Cli::Display.info_message("Include information about your framework (ie Ruby on Rails), your database, how you handle assets, authentication, etc.")
+            Cli::Display.info_message("The more detailed you are the better the LLM will perform.")
+            context = Cli::Display.get_input("context: ")
+            
+            Cli::Display.info_message("If you haven't already, sign up for an API key at https://pairprogrammer.io")
+            Cli::Display.info_message("To skip for now and update later press enter")
+            api_key = Cli::Display.get_input("api_key: ")
+            
+            Cli::Display.info_message("If you are running a python app, which python binary are you using? (python, python2, python3)")
+            Cli::Display.info_message("If you are not using python, press enter to skip")
+            python_command = Cli::Display.select("python command: (choose none if you are not using python)", {"python" => "python", "python2" => "python2", "python3" => "python3", "none" => ""})
+            
+            Cli::Configuration.create(context, api_key, python_command)
+            Cli::Display.success_message("successfully created #{Cli::Configuration::FILE_NAME} - you can update this file at any time")
+            Cli::Display.info_message("Please add it to your .gitignore file")
+        end
+
+        def self.check_cli_version
+            versions = PairProgrammer::Api::System.versions
+            if versions["cli"] != Cli::Version::VERSION
+                Cli::Display.info_message("A new version of the CLI is available, installing update")
+                gem = PairProgrammer::Configuration.development? ? "pear-programmer-0.1.gem" : "pear-programmer"
+                Cli::Display.info_message("Running gem update #{gem}")
+                system("gem update #{gem}")
+                Cli::Display.success_message("Update complete")
+            end
+        end
+
+        def self.report_exception(command, e)
+            version = Cli::Version::VERSION
+            PairProgrammer::Api::System.client_exception(command, e, version)
+            Cli::Display.error_message("An error occurred")
+            Cli::Display.error_message(e.message)
+        end
+
+        def self.help
+            Cli::Display.info_message "Available Commands:"
+            Cli::Display.info_message "  init - initialize pear-programmer from the root of your project"
+            Cli::Display.info_message "  help"
+            Cli::Display.info_message "  coding (new|start|list)"
+        
+            Cli::Display.info_message "Usage examples:"
+            Cli::Display.info_message "  pairprogrammer init"
+            Cli::Display.info_message "  pairprogrammer help"
+            Cli::Display.info_message "  pairprogrammer coding new"
+            Cli::Display.info_message "  pairprogrammer coding start --id CODER_ID"
+            Cli::Display.info_message "  pairprogrammer coding list"
+        end
+
+        # CODER
+        def self.create_coder(options)
+            config = Cli::Configuration.new
+            context = Cli::Display.get_input("context (press enter to use default): ")
+            if context.empty?
+                Cli::Display.info_message("using default context")
+                Cli::Display.info_message(config.default_context)
+                context = config.default_context
+            end
+            requirements = Cli::Display.get_input("requirements: ")
+            tasks = []
+            while true do
+                task = Cli::Display.get_input("task (press enter to complete): ")
+                if task.empty?
+                    break
+                else
+                    tasks << task
+                end
+            end
+
+            id = PairProgrammer::Api::Coder.create(tasks, context, requirements)
+            puts "Created coding assistant #{id}"
+        end
+
+        def self.run_coder(options)
+            config = Cli::Configuration.new
+            auto = !!options[:auto]
+
+            if options[:id]
+                id = options[:id]
+            else
+                coders = PairProgrammer::Api::Coder.list
+                id = Cli::Display.select("Select your coding assistant:", coders.inject({}) { |hash, coder| hash[coder["requirements"]] = coder["id"]; hash })
+            end
+
+            while true do
+                # RETRY when Net::ReadTimeout
+                spinner = Cli::Display.spinner
+                spinner.auto_spin
+                begin
+                    response = PairProgrammer::Api::Coder.run(id)
+                rescue Net::ReadTimeout
+                    Cli::Display.error_message("connection timed out but coder is still running. reconnecting...")
+                    next
+                ensure
+                    spinner.stop()
+                end
+                
+                if response["running"]
+                    Cli::Display.info_message("coder is still running, will try again in 20 seconds")
+                    sleep(20)
+                    next
+                elsif response["reached_max_length"]
+                    Cli::Display.error_message("conversation has reached its context length due to limitations with LLMs")
+                    Cli::Display.error_message("please create a new coder, this coder will no longer be able to run")
+                    return
+                elsif response["error"]
+                    Cli::Display.error_message("there was an error processing the assistant's response")
+                    Cli::Display.info_message("retrying...")
+                    next
+                end
+
+                if response["available_tokens"] && response["available_tokens"] < 500
+                    Cli::Display.info_message("conversation is getting long and approaching context length limit")
+                    Cli::Display.info_message("this conversation has #{response["available_tokens"]} tokens left")
+                end
+
+                system_message = response["system_message"]
+
+                response_required = true
+                # TODO if there is explanation but no command then response is required
+                if system_message["explanation"] && !system_message["explanation"].empty?
+                    Cli::Display.message("assistant", system_message["explanation"])
+                end
+
+                if system_message["command"]
+                    skip_command = false
+                    command_display = PairProgrammer::Command.display_command(system_message["command"], system_message["arguments"])
+                    Cli::Display.info_message(command_display) if command_display
+                    response_required = false
+                    # command overwrites
+                    if system_message["command"] == "comment"
+                        Cli::Display.message("assistant", system_message["arguments"]["comment"])
+                        response_required = true
+                    elsif system_message["command"] == "ask_question"
+                        Cli::Display.message("assistant", system_message["arguments"]["question"])
+                        response_required = true
+                    else
+                        if system_message["command"] == "write_file"
+                            # this fails if file doesn't exist
+                            file_path = PairProgrammer::Configuration.absolute_path(system_message["arguments"]["file_path"])
+                            begin
+                                original_content = File.read(file_path)
+                            rescue Errno::ENOENT
+                                Cli::Display.error_message("there was an error running the command, notifying assistant of error.")
+                                PairProgrammer::Api::Coder.append_exception(id, e)
+                                Cli::Display.info_message("retrying...")
+                                next
+                            end
+                            
+                            Cli::Display.dispaly_diff(original_content, system_message["arguments"]["content"])
+                            
+                            confirmation = Cli::Display.confirmation("Accept changes?")
+                            if !confirmation
+                                Cli::Display.info_message("changes rejected")
+                                # PairProgrammer::Api::Coder.append_output(id, "COMMAND REJECTED")
+                                skip_command = true
+                                response_required = true
+                            else
+                                Cli::Display.info_message("changes accepted")
+                            end
+                        end
+
+                        if !skip_command
+                            output = nil
+                            begin
+                                output = PairProgrammer::Command.run(system_message["command"], system_message["arguments"])
+                            rescue => e
+                                Cli::Display.error_message("there was an error running the command, notifying assistant of error.")
+                                PairProgrammer::Api::Coder.append_exception(id, e)
+                                Cli::Display.info_message("retrying...")
+                                next
+                            end
+                            PairProgrammer::Api::Coder.append_output(id, output)
+                        end
+                    end
+                end
+
+                while true do
+                    # user does not have to respond if auto is true
+                    if !response_required && auto
+                        break
+                    end
+
+                    display = response_required ? "required" : "optional"
+                    message = Cli::Display.get_input("response (#{display}): ")
+                    if message.empty?
+                        if response_required
+                            Cli::Display.error_message("response required")
+                            next
+                        else
+                            break
+                        end
+                    else
+                        PairProgrammer::Api::Coder.add_user_message(id, message)
+                        response_required = false
+                    end
+                end
+            end
+        end
+
+        def self.list_coders(options)
+            coders = PairProgrammer::Api::Coder.list
+            Cli::Display.table(coders, ["id", "context", "requirements", "tasks", "created_at"])
+        end
+    end
+end

data/lib/cli/configuration.rb

@@ -0,0 +1,73 @@
+require 'yaml'
+
+module Cli
+    class Configuration
+        FILE_NAME = ".pear-programmer.yml"
+
+        def self.create(context, api_key, python_command)
+            if !["python", "python2", "python3", ""].include?(python_command)
+                raise "Invalid python command, please choose python, python2, or python3"
+            end
+            
+            # the version of the configuration file, not cli version
+            config = {
+                "version" => 1.0,
+                "project_settings" => {
+                    "context" => context,
+                },
+                "auth" => {
+                    "api_key" => api_key,
+                }
+            }
+
+            if !python_command.empty?
+                config["commands"] = {
+                    "python" => python_command
+                }
+            end
+
+            File.open(File.join(Dir.pwd, FILE_NAME), "w") do |file|
+                file.write(config.to_yaml)
+            end
+        end
+
+        attr_accessor :root
+        def initialize
+            @root = Dir.pwd
+            @configuration_file_path = File.join(@root, FILE_NAME)
+            if !File.exists?(@configuration_file_path)
+                raise "Pear Programmer configuration file does not exist, please run 'pear-on init' or switch to working directory"
+            end
+            @configuration_file = YAML.load_file(@configuration_file_path)
+
+            # validations
+            if @configuration_file["auth"]&.[]("api_key").nil? || @configuration_file["auth"]["api_key"].empty?
+                raise "Pear Programmer api key is missing. Please add your api key to #{@configuration_file_path}"
+            end
+        end
+
+        def python_command
+            command = @configuration_file&.[]("commands")&.[]("python")
+            if command.nil? || command.empty?
+                nil
+            else
+                command
+            end
+        end
+
+        def api_key
+            @configuration_file["auth"]["api_key"]
+        end
+
+        def default_context
+            @configuration_file["project_settings"]["context"]
+        end
+
+        private
+
+        def update_file(config)
+            File.open(@configuration_file_path, "w") { |file| file.write(config.to_yaml) }
+            @configuration_file = config
+        end
+    end
+end

data/lib/cli/display.rb

@@ -0,0 +1,83 @@
+require 'colorize'
+require 'tty-spinner'
+require 'diffy'
+require 'terminal-table'
+require 'tty-prompt'
+
+module Cli
+    class Display
+        def self.message(role, content)
+            if role == "user"
+                puts("you".colorize(background: :green) + ": " + content)
+            else
+                puts("assistant".colorize(background: :yellow) + ": " + content)
+            end
+        end
+
+        def self.table(rows, headers)
+            rows = rows.map(&:values)        
+            table = Terminal::Table.new(
+              headings: headers,
+              rows: rows
+            )
+
+            puts table
+        end
+
+        def self.select(title, options)
+            prompt = TTY::Prompt.new
+            prompt.select(title.colorize(mode: :bold), options, per_page: 100, columnize: 2)
+        end
+
+        def self.confirmation(title)
+            while true do
+                puts(title.colorize(mode: :bold))
+                print("y/N: ".colorize(mode: :bold))
+                response = STDIN.gets.chomp.downcase
+
+                if response.empty?
+                    puts("Response required".colorize(:red))
+                elsif response == "y"
+                    return true
+                elsif response == "n"
+                    return false
+                else
+                    puts("Invalid response. Must be one letter, case insenstive".colorize(:red))
+                end
+            end
+        end
+
+        def self.get_input(input)
+            print(input.colorize(mode: :bold))
+            STDIN.gets.chomp
+        end
+
+        def self.success_message(message)
+            puts(message.colorize(:green))
+        end
+
+        def self.error_message(message)
+            puts(message.colorize(:red))
+        end
+
+        def self.info_message(message)
+            puts(message.colorize(color: :light_black))
+        end
+
+        def self.spinner(title="running")
+            TTY::Spinner.new("[:spinner] #{title}", format: :spin_2)
+        end
+
+        def self.dispaly_diff(original_content, new_content)
+            Diffy::Diff.new(original_content, new_content, source: 'strings').each do |line|
+                if line.start_with?("+")
+                    puts line.colorize(:green)
+                elsif line.start_with?("-")
+                    puts line.colorize(:red)
+                else
+                    puts line
+                end
+            end
+        end
+    end
+end

data/lib/cli/version.rb

@@ -0,0 +1,5 @@
+module Cli
+    module Version
+        VERSION = "0.1.0"
+    end
+end

data/lib/cli.rb

@@ -0,0 +1,59 @@
+require_relative 'cli/actions'
+require_relative 'pairprogrammer/configuration'
+require_relative 'cli/configuration'
+require 'optionparser'
+require_relative 'cli/display'
+
+
+command = ARGV[0]
+
+if command == "init"
+    Cli::Actions.init
+    return
+elsif command == "help"
+    Cli::Actions.help
+    return
+end
+
+config = Cli::Configuration.new
+PairProgrammer::Configuration.root = config.root
+PairProgrammer::Configuration.api_key = config.api_key
+
+begin
+    if config.python_command
+        PairProgrammer::Configuration.python_command = config.python_command
+    end
+
+    Cli::Actions.check_cli_version
+
+    options = {}
+    case command
+    when 'coding'
+        subcommand = ARGV[1]
+        case subcommand
+        when "new"
+            Cli::Actions.create_coder(options)
+        when "start"
+            OptionParser.new do |opts|
+                opts.banner = "Usage: coder run [options]"
+
+                opts.on('-a', '--auto', 'Specify auto') do
+                    options[:auto] = true
+                end
+            end.parse!
+
+            Cli::Actions.run_coder(options)
+        when "list"
+            Cli::Actions.list_coders(options)
+        else
+            Cli::Display.error_message "Invalid coding command"
+            Cli::Actions.help
+        end
+    else
+        Cli::Display.error_message "Invalid command"
+        Cli::Actions.help
+    end
+rescue => e
+    Cli::Actions.report_exception(ARGV.join(" "), e)
+end
+

data/lib/pairprogrammer/api/client.rb

@@ -0,0 +1,73 @@
+require 'net/http'
+require 'uri'
+require 'json'
+require_relative '../configuration'
+
+module PairProgrammer
+    module Api
+        class Client
+            def initialize
+                @api_key = PairProgrammer::Configuration.api_key
+                # TODO api key is not always required, ie checking version
+                raise "Missing api key" if @api_key.nil?
+
+                @domain = PairProgrammer::Configuration.development? ? 'http://localhost:8000' : 'https://www.pearprogrammer.dev'
+            end
+
+            def get(endpoint, query_params={})
+                encoded_params = URI.encode_www_form(query_params)
+                uri = URI.parse(@domain + endpoint + "?" + encoded_params)
+
+                # Create a new instance of Net::HTTP for the specified URI
+                http = Net::HTTP.new(uri.host, uri.port)
+
+                # Use SSL if the URI scheme is HTTPS
+                http.use_ssl = true if uri.scheme == 'https'
+
+                # Set the open_timeout and read_timeout values (in seconds)
+                # http.open_timeout = 5 # Timeout for opening the connection
+                http.read_timeout = 605 # matches openai timeout
+
+                # Create a GET request
+                request = Net::HTTP::Get.new(uri)
+                request['Pairprogrammer-Api-Key'] = @api_key
+
+                # Make the HTTP GET request and handle the response
+                response = http.request(request)
+                handle_response(response)
+            end
+
+            def post(endpoint, body)
+                uri = URI.parse(@domain + endpoint)
+                request = Net::HTTP::Post.new(uri)
+                request.body = body.to_json
+                request['Content-Type'] = 'application/json'
+                request['Pairprogrammer-Api-Key'] = @api_key
+            
+                # Create a new instance of Net::HTTP for the specified URI
+                http = Net::HTTP.new(uri.host, uri.port)
+            
+                # Use SSL if the URI scheme is HTTPS
+                http.use_ssl = true if uri.scheme == 'https'
+            
+                # Set the open_timeout and read_timeout values (in seconds)
+                # http.open_timeout = 5 # Timeout for opening the connection
+                http.read_timeout = 300 # Timeout for reading the response
+            
+                # Make the HTTP POST request and handle the response
+                response = http.request(request)
+                handle_response(response)
+            end
+
+            private
+
+            def handle_response(response)
+                if response.code.to_i.between?(200, 299)
+                    JSON.parse(response.body) if !response.body.empty?
+                else
+                    raise "Error processing your request #{response.body}"
+                end
+            end
+        end
+    end
+end

data/lib/pairprogrammer/api/coder.rb

@@ -0,0 +1,62 @@
+require_relative 'client'
+
+module PairProgrammer
+    module Api
+        class Coder
+            def self.create(tasks, context, requirements)
+                body = {
+                    tasks: tasks,
+                    context: context,
+                    requirements: requirements,
+                }
+                response = Client.new.post('/api/v1/coder', body)
+                response["id"]
+            end
+
+            def self.create_from_planner(planner_id)
+                body = {
+                    from_planner: true,
+                    planner_id: planner_id
+                }
+                response = Client.new.post('/api/v1/coder', body)
+                response["id"]
+            end
+
+            def self.run(id)
+                body = {
+                    id: id
+                }
+                Client.new.post('/api/v1/coder/run', body)
+            end
+
+            def self.append_output(id, output)
+                body = {
+                    id: id,
+                    output: output
+                }
+                Client.new.post('/api/v1/coder/append_output', body)
+            end
+
+            def self.list
+                Client.new.get('/api/v1/coder/list', {})
+            end
+
+            def self.add_user_message(id, message)
+                body = {
+                    id: id,
+                    message: message
+                }
+                Client.new.post('/api/v1/coder/user_message', body)
+            end
+
+            def self.append_exception(id, e)
+                body = {
+                    exception: e.class.to_s,
+                    exception_message: e.message,
+                    id: id
+                }
+                Client.new.post('/api/v1/coder/append_exception', body)
+            end
+        end
+    end
+end

data/lib/pairprogrammer/api/planner.rb

@@ -0,0 +1,48 @@
+
+module PairProgrammer
+    module Api
+        class Planner
+            def self.create(context, requirements)
+                body = {
+                    context: context,
+                    requirements: requirements,
+                }
+                response = Client.new.post('/api/v1/planner', body)
+                response["id"]
+            end
+
+            def self.messages(id)
+                query = {
+                    id: id
+                }
+                Client.new.get('/api/v1/planner/get_messages', query)
+            end
+
+            def self.run(id)
+                body = {
+                    id: id
+                }
+                Client.new.post('/api/v1/planner/run', body)
+            end
+
+            def self.list
+                Client.new.get('/api/v1/planner/list', {})
+            end
+
+            def self.respond(id, content)
+                body = {
+                    id: id,
+                    content: content
+                }
+                Client.new.post('/api/v1/planner/respond', body)
+            end
+
+            def self.generate_tasks(id)
+                body = {
+                    id: id
+                }
+                Client.new.post('/api/v1/planner/generate_tasks', body)
+            end
+        end
+    end
+end

data/lib/pairprogrammer/api/system.rb

@@ -0,0 +1,22 @@
+require_relative 'client'
+
+module PairProgrammer
+    module Api
+        class System
+            def self.versions
+                Client.new.get('/api/v1/versions', {})
+            end
+
+            def self.client_exception(command, exception, version)
+                body = {
+                    command: command,
+                    exception: exception.class.to_s,
+                    message: exception.message,
+                    backtrace: exception.backtrace,
+                    version: version
+                }
+                Client.new.post('/api/v1/client_exception', body)
+            end
+        end
+    end
+end

data/lib/pairprogrammer/command.rb

@@ -0,0 +1,158 @@
+require_relative 'configuration'
+require 'fileutils'
+require 'open3'
+
+module PairProgrammer
+    class Command
+        def self.display_command(command, arguments)
+            case command
+            when "yarn"
+                "running `yarn #{arguments["command"]}`"
+            when "mv"
+                puts "moving #{arguments["source"]} to #{arguments["destination"]}"
+            when "python"
+                "running `python #{arguments["command"]}`"
+            when "ls"
+                "listing files and directories for #{arguments["directory_path"]}"
+            when "bundle"
+                puts "running `bundle #{arguments["command"]}`"
+            when "rails"
+                "running `rails #{arguments["command"]}`"
+            when "comment"
+                nil
+            when "write_file"
+                puts "updating #{arguments["file_path"]}"
+            when "create_directory"
+                puts "creating directory #{arguments["directory_path"]}"
+            when "delete_file"
+                puts "deleting #{arguments["file_path"]}"
+            when "view_changes"
+                # TODO
+            when "delete_lines"
+                puts "deleting lines #{line_numbers} from #{arguments["file_path"]}"
+            when "rspec"
+                puts "running `rspec #{arguments["file_path"]}`"
+            when "ask_question"
+                nil # will ask question
+            when "read_file"
+                puts "reading #{arguments["file_path"]}"
+            when "update_file"
+                puts "updating #{arguments["file_path"]}"
+            when "create_file"
+                puts "creating #{arguments["file_path"]}"
+            end
+        end
+
+        # default
+        @@default_commands = {
+            python: "python3",
+        }
+
+        def self.python_command
+            PairProgrammer::Configuration.python_command || @@default_commands[:python]
+        end
+
+        def self.run_shell(command)
+            output = ""
+            Open3.popen2e(command) do |stdin, stdout_err, wait_thr|
+                while line = stdout_err.gets
+                    output += line
+                end
+            end
+            output
+        end
+        
+        def self.run(command, arguments)
+            case command
+            when "update_file"
+                file_path = PairProgrammer::Configuration.absolute_path(arguments["file_path"])
+                file_content = File.readlines(file_path)
+                file_content.insert(arguments["line_number"], arguments["content"])
+                File.open(file_path, 'w') do |file|
+                    file_content.each { |line| file.puts(line) }
+                end
+            when "yarn"
+                run_shell "cd #{PairProgrammer::Configuration.root} && yarn #{arguments["command"]}"
+            when "mv"
+                run_shell "cd #{PairProgrammer::Configuration.root} && mv #{arguments["source"]} #{arguments["destination"]}"
+            when "python"
+                run_shell "cd #{PairProgrammer::Configuration.root} && #{python_command} manage.py #{arguments["command"]}"
+            when "ls"
+                run_shell "cd #{PairProgrammer::Configuration.root} && ls #{arguments["directory_path"]}"
+            when "bundle"
+                run_shell "cd #{PairProgrammer::Configuration.root} && bundle #{arguments["command"]}"
+            when "rails"
+                run_shell "cd #{PairProgrammer::Configuration.root} && rails #{arguments["command"]}"
+            when "comment"
+                "comment received"
+            when "write_file"
+                file_path = PairProgrammer::Configuration.absolute_path(arguments["file_path"])
+                File.open(file_path, "w") do |file|
+                    file.puts(arguments["content"])
+                end
+            when "create_directory"
+                directory_path = PairProgrammer::Configuration.absolute_path(arguments["directory_path"])
+                FileUtils.mkdir_p(directory_path)
+            when "delete_file"
+                file_path = PairProgrammer::Configuration.absolute_path(arguments["file_path"])
+                File.delete(file_path)
+            when "view_changes"
+                # TODO
+            when "delete_lines"
+                file_path = PairProgrammer::Configuration.absolute_path(arguments["file_path"])
+                line_numbers = arguments["line_numbers"]
+
+                # Read the contents of the file into memory
+                lines = File.readlines(file_path)
+
+                # Delete the specified lines from the contents
+                lines.delete_if.with_index { |line, index| line_numbers.include?(index) }
+
+                # Write the modified contents back to the file
+                File.write(file_path, lines.join)
+            when "rspec"
+                file_path = PairProgrammer::Configuration.absolute_path(arguments["file_path"])
+                run_shell "cd #{PairProgrammer::Configuration.root} && rspec #{file_path}}"
+            when "ask_question"
+                puts arguments["question"]
+                STDIN.gets.chomp
+            when "read_file"
+                file_path = PairProgrammer::Configuration.absolute_path(arguments["file_path"])
+                if File.exists?(file_path)
+                    File.read(file_path)
+                else
+                    "file does not exist"
+                end
+            when "create_file"
+                # TODO return response if file is already created
+                file_path = PairProgrammer::Configuration.absolute_path(arguments["file_path"])
+                FileUtils.touch(file_path)
+            else
+                raise "Invalid command: #{command}"
+            end
+        end
+
+        # TODO if a process hangs, ie it asks for user input, need to kill it or let the user interact with it
+        def self.run_shell(command)
+            logs = ""
+            Open3.popen2e(command) do |stdin, stdout_err, wait_thr|
+                logs = stdout_err.read
+            end
+            logs
+        end
+
+
+        def self.insert_content_at_line(file_path, content, line_number)
+            # Read the file's content into an array
+            file_content = File.readlines(file_path)
+        
+            # Insert the new content at the desired line number
+            file_content.insert(line_number, content)
+        
+            # Write the modified content back to the file
+            File.open(file_path, 'w') do |file|
+            file_content.each { |line| file.puts(line) }
+            end
+        end
+    end
+end

data/lib/pairprogrammer/configuration.rb

@@ -0,0 +1,43 @@
+module PairProgrammer
+    class Configuration
+
+        @@api_key = nil
+
+        def self.root
+            @@root || ENV["PEAR_PROGRAMMER_ROOT"]
+        end
+
+        def self.api_key
+            @@api_key || ENV["PEAR_PROGRAMMER_API_KEY"]
+        end
+
+        def self.api_key=(api_key)
+            @@api_key = api_key
+        end
+
+        def self.root=(root)
+            @@root = root
+        end
+
+        def self.absolute_path(relative_path)
+            File.join(root, relative_path)
+        end
+
+        def self.python_command
+            @@python_command
+        end
+
+        def self.python_command=(python_command)
+            available_commands = ["python", "python2", "python3"]
+            if available_commands.include?(python_command)
+                @@python_command = python_command
+            else
+                raise "Invalid python command - #{python_command} - command must be one of #{available_commands}"
+            end
+        end
+
+        def self.development?
+            ENV["PEAR_PROGRAMMER_ENV"] == "development"
+        end
+    end
+end

data/lib/pairprogrammer.rb

@@ -0,0 +1,4 @@
+require_relative './pairprogrammer/configuration'
+require_relative './pairprogrammer/command'
+require_relative './pairprogrammer/api/coder'
+require_relative './pairprogrammer/api/system'

data/lib/spec/cli/actions_spec.rb

@@ -0,0 +1,29 @@
+require_relative '../spec_helper'
+require 'cli/actions'
+require 'cli/display'
+require 'cli/configuration'
+
+RSpec.describe Cli::Actions do
+  describe '.run_coder' do
+    let(:mock_api_response) {
+      { 'running' => false, 'system_message' => { 'explanation' => 'This is an explanation', 'command' => 'comment', 'arguments' => { 'comment' => 'This is a comment.' } } }
+    }
+
+    let(:coder_list_response) {
+      [{ "requirements": "test", "id": "abcde" }]
+    }
+
+    xit 'calls the coder API, displays messages, and shows a comment' do
+      config = instance_double('Cli::Configuration')
+      allow(Cli::Configuration).to receive(:new).and_return(config)
+    
+      allow(PairProgrammer::Api::Coder).to receive(:list).and_return(coder_list_response)
+      allow(PairProgrammer::Api::Coder).to receive(:run).and_return(mock_api_response)
+
+      expect(Cli::Display).to receive(:info_message).with('This is an explanation').ordered
+      expect(Cli::Display).to receive(:message).with('assistant', 'This is a comment.').ordered
+
+      Cli::Actions.run_coder({})
+    end
+  end
+end

data/lib/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rspec.info/documentation/ for more information about RSpec
+
+require 'webmock/rspec'
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  ENV["PEAR_PROGRAMMER_ENV"] = "development"
+
+  config.before(:each) do
+    stub_request(:any, /localhost/)
+      .to_return { |_request|
+        {status: 200, body: {response: 'stubbed response'}.to_json, headers: {'Content-Type' => 'application/json'}}
+      }
+    allow(PairProgrammer::Configuration).to receive(:api_key).and_return('fake_api_key')
+  end
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: pear-programmer
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Sam Edelstein
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-06-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: open3
+  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: colorize
+  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: tty-spinner
+  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: terminal-table
+  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: diffy
+  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: tty-prompt
+  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'
+description: A Ruby command line interface gem for integrating with the coding assistant
+  API for various tasks
+email:
+- your.email@example.com
+executables:
+- pear-on
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/pear-on
+- lib/cli.rb
+- lib/cli/actions.rb
+- lib/cli/configuration.rb
+- lib/cli/display.rb
+- lib/cli/version.rb
+- lib/pairprogrammer.rb
+- lib/pairprogrammer/api/client.rb
+- lib/pairprogrammer/api/coder.rb
+- lib/pairprogrammer/api/planner.rb
+- lib/pairprogrammer/api/system.rb
+- lib/pairprogrammer/command.rb
+- lib/pairprogrammer/configuration.rb
+- lib/spec/cli/actions_spec.rb
+- lib/spec/spec_helper.rb
+homepage: https://github.com/username/pairprogrammer
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Ruby CLI for interacting with coding assistant API
+test_files: []