roast-ai 0.4.1 → 0.4.3

data/lib/roast/workflow/sqlite_state_repository.rb

@@ -29,13 +29,13 @@ module Roast
 
         session_id = ensure_session(workflow)
 
-        @db.execute(<<~SQL, session_id, state_data[:order], step_name, state_data.to_json)
+        @db.execute(<<~SQL, [session_id, state_data[:order], step_name, state_data.to_json])
           INSERT INTO session_states (session_id, step_index, step_name, state_data)
           VALUES (?, ?, ?, ?)
         SQL
 
         # Update session's current step
-        @db.execute(<<~SQL, state_data[:order], session_id)
+        @db.execute(<<~SQL, [state_data[:order], session_id])
           UPDATE sessions#{" "}
           SET current_step_index = ?, updated_at = CURRENT_TIMESTAMP
           WHERE id = ?
@@ -49,7 +49,7 @@ module Roast
         return false unless session_id
 
         # Find the state before the target step
-        result = @db.execute(<<~SQL, session_id, step_name)
+        result = @db.execute(<<~SQL, [session_id, step_name])
           SELECT state_data, step_name
           FROM session_states
           WHERE session_id = ?
@@ -64,7 +64,7 @@ module Roast
 
         if result.empty?
           # Try to find the latest state if target step doesn't exist
-          result = @db.execute(<<~SQL, session_id)
+          result = @db.execute(<<~SQL, [session_id])
             SELECT state_data, step_name
             FROM session_states
             WHERE session_id = ?
@@ -95,7 +95,7 @@ module Roast
 
         session_id = ensure_session(workflow)
 
-        @db.execute(<<~SQL, output_content, session_id)
+        @db.execute(<<~SQL, [output_content, session_id])
           UPDATE sessions#{" "}
           SET final_output = ?, status = 'completed', updated_at = CURRENT_TIMESTAMP
           WHERE id = ?
@@ -130,7 +130,7 @@ module Roast
 
         where_clause = conditions.empty? ? "" : "WHERE #{conditions.join(" AND ")}"
 
-        @db.execute(<<~SQL, *params)
+        @db.execute(<<~SQL, params)
           SELECT id, workflow_name, workflow_path, status, current_step_index,#{" "}
                  created_at, updated_at
           FROM sessions
@@ -141,20 +141,20 @@ module Roast
       end
 
       def get_session_details(session_id)
-        session = @db.execute(<<~SQL, session_id).first
+        session = @db.execute(<<~SQL, [session_id]).first
           SELECT * FROM sessions WHERE id = ?
         SQL
 
         return unless session
 
-        states = @db.execute(<<~SQL, session_id)
+        states = @db.execute(<<~SQL, [session_id])
           SELECT step_index, step_name, created_at
           FROM session_states
           WHERE session_id = ?
           ORDER BY step_index
         SQL
 
-        events = @db.execute(<<~SQL, session_id)
+        events = @db.execute(<<~SQL, [session_id])
           SELECT event_name, event_data, received_at
           FROM session_events
           WHERE session_id = ?
@@ -170,7 +170,7 @@ module Roast
 
       def cleanup_old_sessions(older_than)
         count = @db.changes
-        @db.execute(<<~SQL, "-#{older_than}")
+        @db.execute(<<~SQL, ["-#{older_than}"])
           DELETE FROM sessions
           WHERE created_at < datetime('now', ?)
         SQL
@@ -181,7 +181,7 @@ module Roast
         # Find the session if session_id not provided
         unless session_id
           workflow_name = File.basename(File.dirname(workflow_path))
-          result = @db.execute(<<~SQL, workflow_name, "waiting")
+          result = @db.execute(<<~SQL, [workflow_name, "waiting"])
             SELECT id FROM sessions
             WHERE workflow_name = ? AND status = ?
             ORDER BY created_at DESC
@@ -194,13 +194,13 @@ module Roast
         end
 
         # Add the event
-        @db.execute(<<~SQL, session_id, event_name, event_data&.to_json)
+        @db.execute(<<~SQL, [session_id, event_name, event_data&.to_json])
           INSERT INTO session_events (session_id, event_name, event_data)
           VALUES (?, ?, ?)
         SQL
 
         # Update session status
-        @db.execute(<<~SQL, session_id)
+        @db.execute(<<~SQL, [session_id])
           UPDATE sessions#{" "}
           SET status = 'running', updated_at = CURRENT_TIMESTAMP
           WHERE id = ?
@@ -272,14 +272,14 @@ module Roast
         session_id = generate_session_id(workflow)
 
         # Check if session exists
-        existing = @db.execute("SELECT id FROM sessions WHERE id = ?", session_id).first
+        existing = @db.execute("SELECT id FROM sessions WHERE id = ?", [session_id]).first
         return session_id if existing
 
         # Create new session
         workflow_name = workflow.session_name || "unnamed"
         workflow_path = workflow.file || "notarget"
 
-        @db.execute(<<~SQL, session_id, workflow_name, workflow_path)
+        @db.execute(<<~SQL, [session_id, workflow_name, workflow_path])
           INSERT INTO sessions (id, workflow_name, workflow_path)
           VALUES (?, ?, ?)
         SQL
@@ -296,7 +296,7 @@ module Roast
           workflow_name = workflow.session_name || "unnamed"
           workflow_path = workflow.file || "notarget"
 
-          result = @db.execute(<<~SQL, workflow_name, workflow_path)
+          result = @db.execute(<<~SQL, [workflow_name, workflow_path])
             SELECT id FROM sessions
             WHERE workflow_name = ? AND workflow_path = ?
             ORDER BY created_at DESC
@@ -324,7 +324,7 @@ module Roast
         new_session_id = ensure_session(workflow)
 
         # Copy states up to the target step
-        @db.execute(<<~SQL, new_session_id, source_session_id, target_step_name, source_session_id)
+        @db.execute(<<~SQL, [new_session_id, source_session_id, target_step_name, source_session_id])
           INSERT INTO session_states (session_id, step_index, step_name, state_data)
           SELECT ?, step_index, step_name, state_data
           FROM session_states

data/lib/roast/workflow/state_manager.rb

@@ -42,6 +42,7 @@ module Roast
           order: determine_step_order(step_name),
           transcript: extract_transcript,
           output: extract_output,
+          metadata: extract_metadata,
           final_output: extract_final_output,
           execution_order: extract_execution_order,
         }
@@ -68,6 +69,13 @@ module Roast
         workflow.output.clone
       end
 
+      # Extract metadata if available
+      def extract_metadata
+        return {} unless workflow.respond_to?(:metadata)
+
+        workflow.metadata.clone
+      end
+
       # Extract final output data if available
       def extract_final_output
         return [] unless workflow.respond_to?(:final_output)

data/lib/roast/workflow/step_executor_coordinator.rb

@@ -38,7 +38,7 @@ module Roast
               Kernel.binding.irb # rubocop:disable Lint/Debugger
             end
           else
-            step_orchestrator.execute_step(step, is_last_step: is_last_step)
+            execute_custom_step(step, is_last_step: is_last_step)
           end
         end
       end
@@ -54,6 +54,10 @@ module Roast
       # @return [Object] The result of the step execution
       def execute(step, options = {})
         step_type = StepTypeResolver.resolve(step, @context)
+        step_name = StepTypeResolver.extract_name(step)
+
+        Thread.current[:current_step_name] = step_name if step_name
+        Thread.current[:workflow_metadata] = @context.workflow.metadata
 
         case step_type
         when StepTypeResolver::COMMAND_STEP
@@ -126,14 +130,18 @@ module Roast
         )
       end
 
-      def step_orchestrator
-        dependencies[:step_orchestrator]
-      end
-
       def error_handler
         dependencies[:error_handler]
       end
 
+      def step_loader
+        dependencies[:step_loader]
+      end
+
+      def state_manager
+        dependencies[:state_manager]
+      end
+
       def execute_command_step(step, options)
         exit_on_error = options.fetch(:exit_on_error, true)
         resource_type = @context.resource_type
@@ -185,8 +193,11 @@ module Roast
         step_name = StepTypeResolver.extract_name(step)
 
         # Load and execute the agent step
-        exit_on_error = options.fetch(:exit_on_error, context.exit_on_error?(step))
-        step_orchestrator.execute_step(step_name, exit_on_error:, step_key: options[:step_key], agent_type: :coding_agent)
+        merged_options = options.merge(
+          exit_on_error: options.fetch(:exit_on_error) { context.exit_on_error?(step) },
+          agent_type: :coding_agent,
+        )
+        execute_custom_step(step_name, **merged_options)
       end
 
       def execute_glob_step(step, options = {})
@@ -259,7 +270,7 @@ module Roast
         exit_on_error = options.fetch(:exit_on_error, true)
         step_key = options[:step_key]
         is_last_step = options[:is_last_step]
-        step_orchestrator.execute_step(step, exit_on_error:, step_key:, is_last_step:)
+        execute_custom_step(step, exit_on_error:, step_key:, is_last_step:)
       end
 
       def validate_each_step!(step)
@@ -268,6 +279,30 @@ module Roast
             "Invalid 'each' step format. 'as' and 'steps' must be at the same level as 'each'"
         end
       end
+
+      def execute_custom_step(name, step_key: nil, **options)
+        resource_type = @context.workflow.respond_to?(:resource) ? @context.workflow.resource&.type : nil
+
+        error_handler.with_error_handling(name, resource_type: resource_type) do
+          $stderr.puts "Executing: #{name} (Resource type: #{resource_type || "unknown"})"
+
+          # Use step_key for loading if provided, otherwise use name
+          load_key = step_key || name
+          is_last_step = options[:is_last_step]
+          step_object = step_loader.load(name, exit_on_error: false, step_key: load_key, is_last_step:, **options)
+          step_result = step_object.call
+
+          # Store result in workflow output
+          # Use step_key for output storage if provided (for hash steps)
+          output_key = step_key || name
+          @context.workflow.output[output_key] = step_result
+
+          # Save state after each step
+          state_manager.save_state(name, step_result)
+
+          step_result
+        end
+      end
     end
   end
 end

data/lib/roast/workflow/step_executor_with_reporting.rb

@@ -11,12 +11,12 @@ module Roast
         @name_extractor = StepNameExtractor.new
       end
 
-      def execute(step, options = {})
+      def execute(step, **options)
         # Track tokens before execution
         tokens_before = @context.workflow.context_manager&.total_tokens || 0
 
         # Execute the step
-        result = @base_executor.execute(step, options)
+        result = @base_executor.execute(step, **options)
 
         # Report token consumption after successful execution
         tokens_after = @context.workflow.context_manager&.total_tokens || 0

data/lib/roast/workflow/step_loader.rb

@@ -60,10 +60,15 @@ module Roast
           return step
         end
 
-        # Look for Ruby file in various locations
-        step_file_path = find_step_file(name.to_s, per_step_path)
-        if step_file_path
-          return load_ruby_step(step_file_path, name.to_s, is_last_step:)
+        # Look for Ruby or shell script file in various locations
+        step_file_info = find_step_file(name.to_s, per_step_path)
+        if step_file_info
+          case step_file_info[:type]
+          when :ruby
+            return load_ruby_step(step_file_info[:path], name.to_s, is_last_step:)
+          when :shell
+            return load_shell_script_step(step_file_info[:path], name.to_s, step_key, is_last_step:)
+          end
         end
 
         # Look for step directory
@@ -87,28 +92,40 @@ module Roast
         File.expand_path(path, context_path)
       end
 
-      # Find a Ruby step file in various locations
+      # Find a Ruby or shell script step file in various locations
       def find_step_file(step_name, per_step_path = nil)
         # Check in per-step path first
         if per_step_path
           resolved_per_step_path = resolve_path(per_step_path)
           custom_rb_path = File.join(resolved_per_step_path, "#{step_name}.rb")
-          return custom_rb_path if File.file?(custom_rb_path)
+          return { path: custom_rb_path, type: :ruby } if File.file?(custom_rb_path)
+
+          custom_sh_path = File.join(resolved_per_step_path, "#{step_name}.sh")
+          return { path: custom_sh_path, type: :shell } if File.file?(custom_sh_path)
         end
 
         # Check in phase-specific directory first
         if phase != :steps
           phase_rb_path = File.join(context_path, phase.to_s, "#{step_name}.rb")
-          return phase_rb_path if File.file?(phase_rb_path)
+          return { path: phase_rb_path, type: :ruby } if File.file?(phase_rb_path)
+
+          phase_sh_path = File.join(context_path, phase.to_s, "#{step_name}.sh")
+          return { path: phase_sh_path, type: :shell } if File.file?(phase_sh_path)
         end
 
         # Check in context path
         rb_file_path = File.join(context_path, "#{step_name}.rb")
-        return rb_file_path if File.file?(rb_file_path)
+        return { path: rb_file_path, type: :ruby } if File.file?(rb_file_path)
+
+        sh_file_path = File.join(context_path, "#{step_name}.sh")
+        return { path: sh_file_path, type: :shell } if File.file?(sh_file_path)
 
         # Check in shared directory
         shared_rb_path = File.expand_path(File.join(context_path, "..", "shared", "#{step_name}.rb"))
-        return shared_rb_path if File.file?(shared_rb_path)
+        return { path: shared_rb_path, type: :ruby } if File.file?(shared_rb_path)
+
+        shared_sh_path = File.expand_path(File.join(context_path, "..", "shared", "#{step_name}.sh"))
+        return { path: shared_sh_path, type: :shell } if File.file?(shared_sh_path)
 
         nil
       end
@@ -161,6 +178,23 @@ module Roast
         step
       end
 
+      # Load a shell script step from a file
+      def load_shell_script_step(file_path, step_name, step_key, is_last_step: nil)
+        $stderr.puts "Loading shell script step: #{file_path}"
+
+        step_name_obj = Roast::ValueObjects::StepName.new(step_name)
+
+        step = ShellScriptStep.new(
+          workflow,
+          script_path: file_path,
+          name: step_name_obj,
+          context_path: File.dirname(file_path),
+        )
+
+        configure_step(step, step_key || step_name, is_last_step:)
+        step
+      end
+
       # Create and configure a step instance
       def create_step_instance(step_class, step_name, context_path, options = {})
         is_last_step = options[:is_last_step]
@@ -203,6 +237,18 @@ module Roast
         if step_config.key?("available_tools")
           step.available_tools = step_config["available_tools"]
         end
+
+        # Apply any other configuration attributes that the step supports
+        step_config.each do |key, value|
+          # Skip keys we've already handled above
+          next if ["print_response", "json", "params", "coerce_to", "available_tools"].include?(key)
+
+          # Apply configuration if the step has a setter for this attribute
+          setter_method = "#{key}="
+          if step.respond_to?(setter_method)
+            step.public_send(setter_method, value)
+          end
+        end
       end
     end
   end

data/lib/roast/workflow/workflow_executor.rb

@@ -42,7 +42,6 @@ module Roast
       # @param state_manager [StateManager] Optional custom state manager
       # @param iteration_executor [IterationExecutor] Optional custom iteration executor
       # @param conditional_executor [ConditionalExecutor] Optional custom conditional executor
-      # @param step_orchestrator [StepOrchestrator] Optional custom step orchestrator
       # @param step_executor_coordinator [StepExecutorCoordinator] Optional custom step executor coordinator
       # @param phase [Symbol] The execution phase - determines where to load steps from
       #   Valid values:
@@ -52,7 +51,7 @@ module Roast
       def initialize(workflow, config_hash, context_path,
         error_handler: nil, step_loader: nil, command_executor: nil,
         interpolator: nil, state_manager: nil, iteration_executor: nil,
-        conditional_executor: nil, step_orchestrator: nil, step_executor_coordinator: nil,
+        conditional_executor: nil, step_executor_coordinator: nil,
         phase: :steps)
         # Create context object to reduce data clump
         @context = WorkflowContext.new(
@@ -69,7 +68,6 @@ module Roast
         @state_manager = state_manager || StateManager.new(workflow, logger: @error_handler, storage_type: workflow.storage_type)
         @iteration_executor = iteration_executor || IterationExecutor.new(workflow, context_path, @state_manager, config_hash)
         @conditional_executor = conditional_executor || ConditionalExecutor.new(workflow, context_path, @state_manager, self)
-        @step_orchestrator = step_orchestrator || StepOrchestrator.new(workflow, @step_loader, @state_manager, @error_handler, self)
 
         # Initialize coordinator with dependencies
         base_coordinator = step_executor_coordinator || StepExecutorCoordinator.new(
@@ -80,7 +78,8 @@ module Roast
             command_executor: @command_executor,
             iteration_executor: @iteration_executor,
             conditional_executor: @conditional_executor,
-            step_orchestrator: @step_orchestrator,
+            step_loader: @step_loader,
+            state_manager: @state_manager,
             error_handler: @error_handler,
           },
         )

data/lib/roast/workflow/workflow_initializer.rb

@@ -10,6 +10,7 @@ module Roast
 
       def setup
         load_roast_initializers
+        check_raix_configuration
         include_tools
         configure_api_client
       end
@@ -20,18 +21,108 @@ module Roast
         Roast::Initializers.load_all
       end
 
+      def check_raix_configuration
+        # Skip check in test environment
+        return if ENV["RAILS_ENV"] == "test" || ENV["RACK_ENV"] == "test" || defined?(Minitest)
+
+        # Only check if the workflow has steps that would need API access
+        return if @configuration.steps.empty?
+
+        # Check if Raix has been configured with the appropriate client
+        case @configuration.api_provider
+        when :openai
+          if Raix.configuration.openai_client.nil?
+            warn_about_missing_raix_configuration(:openai)
+          end
+        when :openrouter
+          if Raix.configuration.openrouter_client.nil?
+            warn_about_missing_raix_configuration(:openrouter)
+          end
+        when nil
+          # If no api_provider is set but we have steps that might need API access,
+          # check if any client is configured
+          if Raix.configuration.openai_client.nil? && Raix.configuration.openrouter_client.nil?
+            warn_about_missing_raix_configuration(:any)
+          end
+        end
+      end
+
+      def warn_about_missing_raix_configuration(provider)
+        ::CLI::UI.frame_style = :box
+        ::CLI::UI::Frame.open("{{red:Raix Configuration Missing}}", color: :red) do
+          case provider
+          when :openai
+            puts ::CLI::UI.fmt("{{yellow:⚠️  Warning: Raix OpenAI client is not configured!}}")
+          when :openrouter
+            puts ::CLI::UI.fmt("{{yellow:⚠️  Warning: Raix OpenRouter client is not configured!}}")
+          else
+            puts ::CLI::UI.fmt("{{yellow:⚠️  Warning: Raix is not configured!}}")
+          end
+          puts
+          puts "Roast requires Raix to be properly initialized to make API calls."
+          puts ::CLI::UI.fmt("To fix this, create a file at {{cyan:.roast/initializers/raix.rb}} with:")
+          puts
+          puts ::CLI::UI.fmt("{{cyan:# frozen_string_literal: true}}")
+          puts
+          puts ::CLI::UI.fmt("{{cyan:require \"raix\"}}")
+
+          if provider == :openrouter
+            puts ::CLI::UI.fmt("{{cyan:require \"open_router\"}}")
+            puts
+            puts ::CLI::UI.fmt("{{cyan:Raix.configure do |config|}}")
+            puts ::CLI::UI.fmt("{{cyan:  config.openrouter_client = OpenRouter::Client.new(}}")
+            puts ::CLI::UI.fmt("{{cyan:    access_token: ENV.fetch(\"OPENROUTER_API_KEY\"),}}")
+            puts ::CLI::UI.fmt("{{cyan:    uri_base: \"https://openrouter.ai/api/v1\",}}")
+            puts ::CLI::UI.fmt("{{cyan:  )}}")
+          else
+            puts
+            puts ::CLI::UI.fmt("{{cyan:faraday_retry = false}}")
+            puts ::CLI::UI.fmt("{{cyan:begin}}")
+            puts ::CLI::UI.fmt("{{cyan:  require \"faraday/retry\"}}")
+            puts ::CLI::UI.fmt("{{cyan:  faraday_retry = true}}")
+            puts ::CLI::UI.fmt("{{cyan:rescue LoadError}}")
+            puts ::CLI::UI.fmt("{{cyan:  # Do nothing}}")
+            puts ::CLI::UI.fmt("{{cyan:end}}")
+            puts
+            puts ::CLI::UI.fmt("{{cyan:Raix.configure do |config|}}")
+            puts ::CLI::UI.fmt("{{cyan:  config.openai_client = OpenAI::Client.new(}}")
+            puts ::CLI::UI.fmt("{{cyan:    access_token: ENV.fetch(\"OPENAI_API_KEY\"),}}")
+            puts ::CLI::UI.fmt("{{cyan:    uri_base: \"https://api.openai.com/v1\",}}")
+            puts ::CLI::UI.fmt("{{cyan:  ) do |f|}}")
+            puts ::CLI::UI.fmt("{{cyan:    if faraday_retry}}")
+            puts ::CLI::UI.fmt("{{cyan:      f.request(:retry, {}}")
+            puts ::CLI::UI.fmt("{{cyan:        max: 2,}}")
+            puts ::CLI::UI.fmt("{{cyan:        interval: 0.05,}}")
+            puts ::CLI::UI.fmt("{{cyan:        interval_randomness: 0.5,}}")
+            puts ::CLI::UI.fmt("{{cyan:        backoff_factor: 2,}}")
+            puts ::CLI::UI.fmt("{{cyan:      })}}")
+            puts ::CLI::UI.fmt("{{cyan:    end}}")
+            puts ::CLI::UI.fmt("{{cyan:  end}}")
+          end
+          puts ::CLI::UI.fmt("{{cyan:end}}")
+          puts
+          puts "For Shopify users, you need to use the LLM gateway proxy instead."
+          puts "Check the #roast slack channel for more information."
+          puts
+        end
+        raise ::CLI::Kit::Abort, "Please configure Raix before running workflows."
+      end
+
       def include_tools
         return unless @configuration.tools.present? || @configuration.mcp_tools.present?
 
-        BaseWorkflow.include(Raix::FunctionDispatch)
-        BaseWorkflow.include(Roast::Helpers::FunctionCachingInterceptor) # Add caching support
+        # Only include modules if they haven't been included already to avoid method redefinition warnings
+        BaseWorkflow.include(Raix::FunctionDispatch) unless BaseWorkflow.included_modules.include?(Raix::FunctionDispatch)
+        BaseWorkflow.include(Roast::Helpers::FunctionCachingInterceptor) unless BaseWorkflow.included_modules.include?(Roast::Helpers::FunctionCachingInterceptor)
 
         if @configuration.tools.present?
-          BaseWorkflow.include(*@configuration.tools.map(&:constantize))
+          @configuration.tools.map(&:constantize).each do |tool|
+            BaseWorkflow.include(tool) unless BaseWorkflow.included_modules.include?(tool)
+          end
         end
 
         if @configuration.mcp_tools.present?
-          BaseWorkflow.include(Raix::MCP)
+          BaseWorkflow.include(Raix::MCP) unless BaseWorkflow.included_modules.include?(Raix::MCP)
 
           # Create an interpolator for MCP tool configuration
           # We use Object.new as the context because this interpolation happens during

data/lib/roast/workflow/workflow_runner.rb

@@ -91,11 +91,11 @@ module Roast
         executor = WorkflowExecutor.new(workflow, @configuration.config_hash, @configuration.context_path)
         executor.execute_steps(steps)
 
-        $stderr.puts "🔥🔥🔥 ROAST COMPLETE! 🔥🔥🔥"
-
         # Save outputs
         @output_handler.save_final_output(workflow)
         @output_handler.write_results(workflow)
+
+        $stderr.puts "🔥🔥🔥 ROAST COMPLETE! 🔥🔥🔥"
       end
 
       private

data/lib/roast.rb

@@ -11,6 +11,7 @@ require "net/http"
 require "open3"
 require "pathname"
 require "securerandom"
+require "shellwords"
 require "tempfile"
 require "uri"
 require "yaml"
@@ -25,6 +26,7 @@ require "active_support/core_ext/string/inflections"
 require "active_support/isolated_execution_state"
 require "active_support/notifications"
 require "cli/ui"
+require "cli/kit"
 require "diff/lcs"
 require "json-schema"
 require "raix"

data/roast.gemspec

@@ -37,13 +37,14 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency("activesupport", ">= 7.0")
+  spec.add_dependency("cli-kit", "~> 5.0")
   spec.add_dependency("cli-ui", "2.3.0")
   spec.add_dependency("diff-lcs", "~> 1.5")
-  spec.add_dependency("faraday-retry")
   spec.add_dependency("json-schema")
   spec.add_dependency("open_router", "~> 0.3")
-  spec.add_dependency("raix", "~> 1.0")
+  spec.add_dependency("raix-openai-eight", "~> 1.0")
   spec.add_dependency("ruby-graphviz", "~> 1.2")
+  spec.add_dependency("sqlite3", "~> 2.6")
   spec.add_dependency("thor", "~> 1.3")
   spec.add_dependency("zeitwerk", "~> 2.6")
 end