sublayer 0.2.3 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b88b5a8d08e537fed46f26b445126a1482f13e79732a545b225c6b6447e9417
-  data.tar.gz: 7903ce4058e07fa95faee094bc937f41eb297d23a941a8f2287365c052773797
+  metadata.gz: ae309181fe8ac4451cb6740fbaaea2599539969ec10d67efe2de75a62e485194
+  data.tar.gz: 0c2f60f772efebe97bd2b9d1da34c6545a8bf67aa9f2dded954a5bb9a3c523f8
 SHA512:
-  metadata.gz: 07701102f65938db5dc6e9c1ed3de303073c4a185ecde0fc12c458e6051294d3bd00def3f89219663dc6f6f879b4aac29f84163b000f310bf18831fa94d3e831
-  data.tar.gz: e5c34b702ba9aabb599e4d95e13671ef3a433c577dc0a68fd2d1a3ff938d137819da31908ee11cd8eed334fb16dc02f08cd99be21f33ef41dd00db3d5e728065
+  metadata.gz: cffeb06614a0925c823fc0f05c79361b381146e6cba825d697f8796a8c961138f307c23faaf4fed2c4c2f5fcf532255e1374da148b4de427914fc51a9b16e0b0
+  data.tar.gz: 68d200d5297030675c4ce4616e30d25500f58e060e16ac22f8ddb3e6daf51d52f13ba0a92d9da85d27d5669c4106cc2a55feda98bcdf2a6846c1e098c3b84cb3

data/bin/sublayer

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/sublayer/cli"
+
+Sublayer::CLI.start(ARGV)

data/lib/sublayer/cli/commands/action.rb

@@ -0,0 +1,65 @@
+require_relative "./generators/sublayer_action_generator"
+
+module Sublayer
+  module Commands
+    class Action < Thor::Group
+      include Thor::Actions
+
+      class_option :description, type: :string, desc: "Description of the action you want to generate", aliases: :d
+      class_option :provider, type: :string, desc: "AI provider (OpenAI, Claude, or Gemini)", aliases: :p
+      class_option :model, type: :string, desc: "AI model name to use (e.g. gpt-4o, claude-3-haiku-20240307, gemini-1.5-flash-latest)", aliases: :m
+
+      def confirm_usage_of_ai_api
+        puts "You are about to generate a new agent that uses an AI API to generate content."
+        puts "Please ensure you have the necessary API keys and that you are aware of the costs associated with using the API."
+        exit unless yes?("Do you want to continue?")
+      end
+
+      def determine_available_providers
+        @available_providers = []
+
+        @available_providers << "OpenAI" if ENV["OPENAI_API_KEY"]
+        @available_providers << "Claude" if ENV["ANTHROPIC_API_KEY"]
+        @available_providers << "Gemini" if ENV["GEMINI_API_KEY"]
+      end
+
+      def ask_for_action_details
+        @ai_provider = options[:provider] || ask("Select an AI provider:", default: "OpenAI", limited_to: @available_providers)
+        @ai_model = options[:model] || select_ai_model
+
+        @description = options[:description] || ask("Enter a description for the Sublayer Action you'd like to create:")
+      end
+
+      def generate_action
+        @results = SublayerActionGenerator.new(description: @description).generate
+      end
+
+      def determine_destination_folder
+        @destination_folder = if File.directory?("./actions")
+                                "./actions"
+                              elsif Dir.glob("./lib/**/actions").any?
+                                Dir.glob("./lib/**/actions").first
+                              else
+                                "./"
+                              end
+      end
+
+      def save_action_to_destination_folder
+        create_file File.join(@destination_folder, @results.filename), @results.code
+      end
+
+      private
+
+      def select_ai_model
+        case @ai_provider
+        when "OpenAI"
+          ask("Which OpenAI model would you like to use?", default: "gpt-4o")
+        when "Claude"
+          ask("Which Anthropic model would you like to use?", default: "claude-3-5-sonnet-20240620")
+        when "Gemini"
+          ask("Which Google model would you like to use?", default: "gemini-1.5-flash-latest")
+        end
+      end
+    end
+  end
+end

data/lib/sublayer/cli/commands/agent.rb

@@ -0,0 +1,79 @@
+require_relative "./generators/sublayer_agent_generator"
+
+module Sublayer
+  module Commands
+    class Agent < Thor::Group
+      include Thor::Actions
+
+      class_option :description, type: :string, desc: "Description of the agent you want to generate", aliases: :d
+      class_option :provider, type: :string, desc: "AI provider (OpenAI, Claude, or Gemini)", aliases: :p
+      class_option :model, type: :string, desc: "AI model name to use (e.g. gpt-4o, claude-3-haiku-20240307, gemini-1.5-flash-latest)", aliases: :m
+
+      def confirm_usage_of_ai_api
+        puts "You are about to generate a new agent that uses an AI API to generate content."
+        puts "Please ensure you have the necessary API keys and that you are aware of the costs associated with using the API."
+        exit unless yes?("Do you want to continue?")
+      end
+
+      def determine_available_providers
+        @available_providers = []
+
+        @available_providers << "OpenAI" if ENV["OPENAI_API_KEY"]
+        @available_providers << "Claude" if ENV["ANTHROPIC_API_KEY"]
+        @available_providers << "Gemini" if ENV["GEMINI_API_KEY"]
+      end
+
+      def ask_for_agent_details
+        @ai_provider = options[:provider] || ask("Select an AI provider:", default: "OpenAI", limited_to: @available_providers)
+        @ai_model = options[:model] || select_ai_model
+        @description = options[:description] || ask("Enter a description for the Sublayer Agent you'd like to create:")
+        @trigger = ask("What should trigger this agent to start acting?")
+        @goal = ask("What is the agent's goal condition?")
+        @check_status = ask("How should the agent check its status toward the goal?")
+        @step = ask("How does the agent take a step toward its goal?")
+      end
+
+      def generate_agent
+        Sublayer.configuration.ai_provider = Object.const_get("Sublayer::Providers::#{@ai_provider}")
+        Sublayer.configuration.ai_model = @ai_model
+
+        say "Generating Sublayer Agent..."
+
+        @results = SublayerAgentGenerator.new(
+          description: @description,
+          trigger: @trigger_explanation,
+          goal: @goal,
+          check_status: @check_status,
+          step: @step
+        ).generate
+      end
+
+      def determine_destination_folder
+        @destination_folder = if File.directory?("./agents")
+                                "./agents"
+                              elsif Dir.glob("./lib/**/agents").any?
+                                Dir.glob("./lib/**/agents").first
+                              else
+                                "./"
+                              end
+      end
+
+      def save_agent_to_destination_folder
+        create_file File.join(@destination_folder, @results.filename), @results.code
+      end
+
+      private
+
+      def select_ai_model
+        case @ai_provider
+        when "OpenAI"
+          ask("Which OpenAI model would you like to use?", default: "gpt-4o")
+        when "Claude"
+          ask("Which Anthropic model would you like to use?", default: "claude-3-5-sonnet-20240620")
+        when "Gemini"
+          ask("Which Google model would you like to use?", default: "gemini-1.5-flash-latest")
+        end
+      end
+    end
+  end
+end

data/lib/sublayer/cli/commands/generator.rb

@@ -0,0 +1,68 @@
+require_relative "generators/sublayer_generator_generator"
+
+module Sublayer
+  module Commands
+    class Generator < Thor::Group
+      include Thor::Actions
+
+      class_option :description, type: :string, desc: "Description of the generator you want to generate", aliases: :d
+      class_option :provider, type: :string, desc: "AI provider (OpenAI, Claude, or Gemini)", aliases: :p
+      class_option :model, type: :string, desc: "AI model name to use (e.g. gpt-4o, claude-3-haiku-20240307, gemini-1.5-flash-latest)", aliases: :m
+
+      def confirm_usage_of_ai_api
+        puts "You are about to generate a new generator that uses an AI API to generate content."
+        puts "Please ensure you have the necessary API keys and that you are aware of the costs associated with using the API."
+        exit unless yes?("Do you want to continue?")
+      end
+
+      def determine_available_providers
+        @available_providers = []
+
+        @available_providers << "OpenAI" if ENV["OPENAI_API_KEY"]
+        @available_providers << "Claude" if ENV["ANTHROPIC_API_KEY"]
+        @available_providers << "Gemini" if ENV["GEMINI_API_KEY"]
+      end
+
+      def ask_for_generator_details
+        @description = options[:description] || ask("Enter a description for the Sublayer Generator you'd like to create:")
+        @ai_provider = options[:provider] || ask("Select an AI provider:", default: "OpenAI", limited_to: @available_providers)
+        @ai_model = options[:model] || select_ai_model
+      end
+
+      def generate_generator
+        Sublayer.configuration.ai_provider = Object.const_get("Sublayer::Providers::#{@ai_provider}")
+        Sublayer.configuration.ai_model = @ai_model
+
+        say "Generating Sublayer Generator..."
+        @results = SublayerGeneratorGenerator.new(description: @description).generate
+      end
+
+      def determine_destination_folder
+        # Find either a ./generators folder or a generators folder nested one level below ./lib
+        @destination_folder = if File.directory?("./generators")
+                                "./generators"
+                              elsif Dir.glob("./lib/**/generators").any?
+                                Dir.glob("./lib/**/generators").first
+                              else
+                                "./"
+                              end
+      end
+
+      def save_generator_to_destination_folder
+        create_file File.join(@destination_folder, @results.filename), @results.code
+      end
+
+      private
+      def select_ai_model
+        case @ai_provider
+        when "OpenAI"
+          ask("Which OpenAI model would you like to use?", default: "gpt-4o")
+        when "Claude"
+          ask("Which Anthropic model would you like to use?", default: "claude-3-5-sonnet-20240620")
+        when "Gemini"
+          ask("Which Google model would you like to use?", default: "gemini-1.5-flash-latest")
+        end
+      end
+    end
+  end
+end

data/lib/sublayer/cli/commands/generators/example_action_api_call.rb

@@ -0,0 +1,23 @@
+class TextToSpeechAction < Sublayer::Actions::Base
+  def initialize(text)
+    @text = text
+  end
+
+  def call
+    speech = HTTParty.post(
+      "https://api.openai.com/v1/audio/speech",
+      headers: {
+        "Authorization" => "Bearer #{ENV["OPENAI_API_KEY"]}",
+        "Content-Type" => "application/json",
+      },
+      body: {
+        "model": "tts-1",
+        "input": @text,
+        "voice": "nova",
+        "response_format": "wav"
+      }.to_json
+    )
+
+    speech
+  end
+end

data/lib/sublayer/cli/commands/generators/example_action_file_manipulation.rb

@@ -0,0 +1,12 @@
+class WriteFileAction < Sublayer::Actions::Base
+  def initialize(file_contents:, file_path:)
+    @file_contents = file_contents
+    @file_path = file_path
+  end
+
+  def call
+    File.open(@file_path, 'wb') do |file|
+      file.write(@file_contents)
+    end
+  end
+end

data/lib/sublayer/cli/commands/generators/example_agent.rb

@@ -0,0 +1,33 @@
+class RSpecAgent < Sublayer::Agents::Base
+  def initialize(implementation_file_path:, test_file_path:)
+    @implementation_file_path = implementation_file_path
+    @test_file_path = test_file_path
+    @tests_passing = false
+  end
+
+  trigger_on_files_changed { [@implementation_file_path, @test_file_path] }
+
+  goal_condition { @tests_passing == true }
+
+  check_status do
+    stdout, stderr, status = Sublayer::Actions::RunTestCommandAction.new(
+      test_command: "rspec #{@test_file_path}"
+    ).call
+
+    @test_output = stdout
+    @tests_passing = (status.exitstatus == 0)
+  end
+
+  step do
+    modified_implementation = Sublayer::Generators::ModifiedImplementationToPassTestsGenerator.new(
+      implementation_file_contents: File.read(@implementation_file_path),
+      test_file_contents: File.read(@test_file_path),
+      test_output: @test_output
+    ).generate
+
+    Sublayer::Actions::WriteFileAction.new(
+      file_contents: modified_implementation,
+      file_path: @implementation_file_path
+    ).call
+  end
+end

data/lib/sublayer/cli/commands/generators/example_generator.rb

@@ -0,0 +1,26 @@
+class CodeFromDescriptionGenerator < Sublayer::Generators::Base
+  llm_output_adapter type: :single_string,
+    name: "generated_code",
+    description: "The generated code in the requested language"
+
+  def initialize(description:, technologies:)
+    @description = description
+    @technologies = technologies
+  end
+
+  def generate
+    super
+  end
+
+  def prompt
+    <<-PROMPT
+        You are an expert programmer in #{@technologies.join(", ")}.
+
+        You are tasked with writing code using the following technologies: #{@technologies.join(", ")}.
+
+        The description of the task is #{@description}
+
+        Take a deep breath and think step by step before you start coding.
+    PROMPT
+  end
+end

data/lib/sublayer/cli/commands/generators/sublayer_action_generator.rb

@@ -0,0 +1,55 @@
+class SublayerActionGenerator < Sublayer::Generators::Base
+  llm_output_adapter type: :named_strings,
+    name: "sublayer_action",
+    description: "The new sublayer action based on the description and supporting information",
+    attributes: [
+      { name: "code", description: "The code of the generated Sublayer action" },
+      { name: "filename", description: "The filename of the generated sublayer action snake cased with a .rb extension" }
+    ]
+
+  def initialize(description:)
+    @description = description
+  end
+
+  def generate
+    super
+  end
+
+  def prompt
+    <<-PROMPT
+    You are an expert ruby programmer and are great at repurposing code examples to use for new situations.
+
+    A Sublayer Action is an example of a command pattern that is used in the Sublayer AI framework to perform actions in the outside world such as manipulating files or making API calls.
+
+    The Sublayer framework also has a component called a Generator that takes data in, sends it to an LLM and gets structured data out.
+    Sublayer::Actions are used both to retrieve data for use in a generator or perform actions based on the output of the generator.
+    This is used to both aid in generating new composable bits of functionality and to ease testing.
+
+    A sublayer action is initialized with the data it needs and then exposes a `call` method which is used to perform the action.
+
+    An example of an action being used to save a file to the file system, for example after generating the contents is:
+    <example_file_manipulation_action>
+    #{example_filesystem_action}
+    </example_file_manipulation_action>
+
+    An example action being used to make a call to an external api, such as OpenAI's text to speech API is:
+    <example_api_call_action>
+    #{example_api_action}
+    </example_api_call_action>
+
+    Your task is to generate a new Sublayer::Action::Base subclass that performs an action based on the description provided.
+    <description>
+    #{@description}
+    </description>
+    PROMPT
+  end
+
+  private
+  def example_filesystem_action
+    File.read(File.join(File.dirname(__FILE__), 'example_action_file_manipulation.rb'))
+  end
+
+  def example_api_action
+    File.read(File.join(File.dirname(__FILE__), 'example_action_api_call.rb'))
+  end
+end

data/lib/sublayer/cli/commands/generators/sublayer_agent_generator.rb

@@ -0,0 +1,61 @@
+class SublayerAgentGenerator < Sublayer::Generators::Base
+  llm_output_adapter type: :named_strings,
+    name: "sublayer_agent",
+    description: "The new sublayer agent based on the description and supporting information",
+    attributes: [
+      { name: "code", description: "The code of the generated Sublayer agent" },
+      { name: "filename", description: "The filename of the generated sublayer agent snake cased with a .rb extension" }
+    ]
+
+  def initialize(description:, trigger:, goal:, check_status:, step:)
+    @description = description
+    @trigger_condition = trigger
+    @goal = goal
+    @check_status = check_status
+    @step = step
+  end
+
+  def generate
+    super
+  end
+
+  def prompt
+    <<-PROMPT
+    You are an expert ruby programmer and great at repurposing code examples to use for new situations.
+
+    A Sublayer agent is a DSL for defining a feedback loop for an AI agent. The agents sit running like a daemon and are triggered to run and step toward their goal checking status along the way.
+
+    One example of a Sublayer agent is this one for doing TDD with RSpec:
+    <example_tdd_agent>
+    #{example_agent}
+    </example_tdd_agent>
+
+    Sublayer Agents take advantage of other Sublayer components to perform their tasks.
+    Sublayer::Actions are used to perform actions in the outside world, things like saving files, making external api calls, retrieving data, etc
+    Sublayer::Generators are used to make calls to LLMs based on information they receive from Sublayer::Actions or other sources and return structured data for other Sublayer::Actions to do use in the outside world
+
+    The Sublayer Agent DSL consists of 4 main parts:
+    1. trigger: What triggers the agent, currently built into the framework is the trigger_on_files_changed, but the trigger method also accepts a Sublayer::Triggers::Base subclass that defines an initialize method and a setup method that takes an agent as an argument
+                The setup method then calls activate(agent) when the trigger condition is met
+    2. goal: What the agent is trying to achieve, this is a block that returns a boolean
+    3. check_status: A method that checks the status of the agent on its way toward the goal. Usually you update the goal condition here or can perform any Sublayer::Actions to examine the state of the outside world
+    4. step: A method that encapsulates the way the agent should work toward the goal. Sublayer::Actions and Sublayer::Generators are used heavily here.
+
+    Your goal is to rely on the above information about how Sublayer Agents work to generate a new Sublayer agent based on the following information:
+
+    Agent description: #{@description}
+    Trigger condition: #{@trigger}
+    Goal condition: #{@goal}
+    Status check method: #{@check_status}
+    Step action method: #{@step}
+
+    You can assume that any Sublayer::Actions or Sublayer::Generators you need are available to you in the Sublayer framework
+
+    Take a deep breath and think step by step before coding. You can do this!
+    PROMPT
+  end
+
+  def example_agent
+    File.read(File.join(__dir__, "example_agent.rb"))
+  end
+end

data/lib/sublayer/cli/commands/generators/sublayer_generator_generator.rb

@@ -0,0 +1,96 @@
+class SublayerGeneratorGenerator < Sublayer::Generators::Base
+  llm_output_adapter type: :named_strings,
+    name: "sublayer_generator",
+    description: "The new Sublayer generator code based on the description",
+    attributes: [
+      { name: "code", description: "The code of the generated Sublayer generator" },
+      { name: "filename", description: "The filename of the generated Sublayer generator snake cased and with a .rb extension" }
+    ]
+
+  def initialize(description:)
+    @description = description
+  end
+
+  def generate
+    super
+  end
+
+  def prompt
+    <<-PROMPT
+    You are an expert ruby programmer and and great at repurposing code examples to use for new situations.
+
+    A Sublayer generator is a class that acts as an abstraction for sending a request to an LLM and getting structured data back.
+
+    An example Sublayer generator is:
+    <example_generator>
+    #{example_generator}
+    </example_generator>
+
+    And it is the generator we're currently using for taking in a description from a user and generating a new Sublayer generator.
+
+    All Sublayer::Generators inherit from Sublayer::Generators::Base and have a generate method that simply calls super for the user to use and modify for their uses.
+
+    the llm_output_adapter directive is used to instruct the LLM on what structure of output to generate. In the example we're using type: :single_string which takes a name and description as arguments.
+
+    the other available options and their example usage is:
+    llm_output_adapter type: :list_of_strings,
+      name: "suggestions",
+      description: "List of keyword suggestions"
+
+    llm_output_adapter type: :single_integer,
+      name: "four_digit_passcode",
+      description: "an uncommon and difficult to guess four digit passcode"
+
+    llm_output_adapter type: :list_of_named_strings,
+      name: "review_summaries",
+      description: "List of movie reviews",
+      item_name: "review",
+      attributes: [
+        { name: "movie_title", description: "The title of the movie" },
+        { name: "reviewer_name", description: "The name of the reviewer" },
+        { name: "rating", description: "The rating given by the reviewer (out of 5 stars)" },
+        { name: "brief_comment", description: "A brief summary of the movie" }
+      ]
+
+    llm_output_adapter type: :named_strings,
+      name: "product_description",
+      description: "Generate product descriptions",
+      attributes: [
+        { name: "short_description", description: "A brief one-sentence description of the product" },
+        { name: "long_description", description: "A detailed paragraph describing the product" },
+        { name: "key_features", description: "A comma-separated list of key product features" },
+        { name: "target_audience", description: "A brief description of the target audience for this product" }
+      ]
+
+    # Where :available_routes is a method that returns an array of available routes
+    llm_output_adapter type: :string_selection_from_list,
+      name: "route",
+      description: "A route selected from the list",
+      options: :available_routes
+
+    # Where @sentiment_options is an array of sentiment values passed in to the initializer
+    llm_output_adapter type: :string_selection_from_list,
+      name: "sentiment_value",
+      description: "A sentiment value from the list",
+      options: -> { @sentiment_options }
+
+    Besides that, a Sublayer::Generator also has a prompt method that describes the task to the LLM and provides any necessary context for the generation which
+    is either passed in through the initializer or accessed in the prompt itself.
+
+    You have a description provided by the user to generate a new sublayer generator.
+
+    You are tasked with creating a new sublayer generator according to the given description.
+
+    Consider the details and requirements mentioned in the description to create the appropriate Sublayer::Generator.
+    <users_description>
+    #{@description}
+    </users_description>
+
+    Take a deep breath and reflect on each aspect of the description before proceeding with the generation.
+    PROMPT
+  end
+
+  def example_generator
+    File.read(File.join(File.dirname(__FILE__), "example_generator.rb"))
+  end
+end

data/lib/sublayer/cli/commands/new_project.rb

@@ -0,0 +1,116 @@
+module Sublayer
+  module Commands
+    class NewProject < Thor::Group
+      include Thor::Actions
+
+      argument :project_name, type: :string, desc: "The name of your project"
+
+      class_option :template, type: :string, desc: "Type of project (CLI or QuickScript)", aliases: :t
+      class_option :provider, type: :string, desc: "AI provider (OpenAI, Claude, or Gemini)", aliases: :p
+      class_option :model, type: :string, desc: "AI model name to use (e.g. gpt-4o, claude-3-haiku-20240307, gemini-1.5-flash-latest)", aliases: :m
+
+      def sublayer_version
+        Sublayer::VERSION
+      end
+
+      def self.source_root
+        File.dirname(__FILE__)
+      end
+
+      def ask_for_project_details
+        puts options[:template]
+        @project_template = options[:template] || ask("Select a project template:", default: "CLI", limited_to: %w[CLI QuickScript])
+        @ai_provider = options[:provider] || ask("Select an AI provider:", default: "OpenAI", limited_to: %w[OpenAI Claude Gemini])
+        @ai_model = options[:model] || select_ai_model
+      end
+
+      def create_project_directory
+        say "Creating project directory", :green
+        empty_directory project_name
+      end
+
+      def copy_template_files
+        say "Copying template files", :green
+        template_dir = @project_template == "CLI" ? "cli" : "quick_script"
+        directory "../templates/#{template_dir}", project_name
+        empty_directory File.join(project_name, "log") if @project_template =="CLI"
+      end
+
+      def generate_config_file
+        say "Generating configuration", :green
+
+        config = {
+          project_name: project_name,
+          project_template: @project_template,
+          ai_provider: @ai_provider,
+          ai_model: @ai_model
+        }
+
+        if @project_template == "CLI"
+          create_file File.join(project_name, "lib", project_name, "config", "sublayer.yml"), YAML.dump(config)
+        else
+          append_to_file File.join(project_name, "#{project_name}.rb") do
+            <<~CONFIG
+            Sublayer.configuration.ai_provider = Sublayer::Providers::#{config[:ai_provider]}
+            Sublayer.configuration.ai_model = "#{config[:ai_model]}"
+            CONFIG
+          end
+        end
+      end
+
+      def finalize_project
+        say "Finalizing project", :green
+        inside(project_name) do
+          if @project_template == "CLI"
+            chmod("bin/#{project_name}", "+x")
+            run("bundle install") if yes?("Install gems?")
+          else
+            append_to_file "#{project_name}.rb" do
+              <<~INSTRUCTIONS
+              puts "Welcome to your quick Sublayer script!"
+              puts "To get started, create some generators, actions, or agents in their respective directories and call them here"
+              puts "For more information, visit https://docs.sublayer.com"
+              INSTRUCTIONS
+            end
+          end
+
+          run("git init") if yes?("Initialize a git repository?")
+        end
+      end
+
+      def print_next_steps
+        say "\nSublayer project '#{project_name}' created successfully!", :green
+        say "To get started, run:"
+        say "  cd #{project_name}"
+        if @project_template == "CLI"
+          say "  ./bin/#{project_name}"
+        else
+          say "  ruby #{project_name}.rb"
+        end
+      end
+
+      private
+
+      def select_ai_model
+        case @ai_provider
+        when "OpenAI"
+          ask("Which OpenAI model would you like to use?", default: "gpt-4o", limited_to: %w[gpt-4o gpt-4o-mini gpt-4-turbo gpt-3.5-turbo])
+        when "Claude"
+          ask("Which Anthropic model would you like to use?", default: "claude-3-5-sonnet-20240620", limited_to: %w[claude-3-5-sonnet-20240620 claude-3-opus-20240620 claude-3-haiku-20240307])
+        when "Gemini"
+          ask("Which Google model would you like to use?", default: "gemini-1.5-flash-latest", limited_to: %w[gemini-1.5-flash-latest gemini-1.5-pro-latest])
+        end
+      end
+
+      def rename_project_name_directory
+        old_path = File.join(project_name, "lib", "PROJECT_NAME")
+        new_path = File.join(project_name, "lib", project_name.gsub("-", "_").downcase)
+
+        if File.directory?(old_path)
+          say "Renaming project directory", :green
+          FileUtils.mv(old_path, new_path)
+        end
+      end
+    end
+  end
+end