roast-ai 0.4.6 → 0.4.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b30690bd6345f217ff752e69865abf269792917e6463bbb70745a812ec15a4b
-  data.tar.gz: de3732ccd3322fb8ff782d10e52168e0e4292fdb21596ff0eff7201532498c8d
+  metadata.gz: '0019e9658942394301e91581ecc45b259c76f1999f17cc8f1ddf4f97692ea639'
+  data.tar.gz: feb3d19b4316a2ea2751347a614f816c22cbd53182821eed661488c760a9897a
 SHA512:
-  metadata.gz: ba81d35b6484ffbdb3bb5aaed1baacbbc684033e62df23131c6d0bcb7833bc0902600f84a462fb451213d56c43862e49e8db5bfd150fb4a7520b66cd1e078d85
-  data.tar.gz: 01b3d585d72528c5d8382a13edd379f6af249d75059564adb8eb33671b2dfb252749a09f8e2d8a551b09fad048b735960fcf8f2cf37d1c0f1d06aa758feee50d
+  metadata.gz: b8c5442247e1e0aae1cb7aa4509a3724fb1867bf9b05b15cfe1da4a8287db1db8229026ad3be66cc450b57650e8dd00d4eca632021680f3320d2bbf8dd19fc89
+  data.tar.gz: bbf18e07720a9cfe48abc2780f0f2cdba7d091bb3b2103318556910693dc54b09980ac0f2133876a811700345cdb6fa9e32d87cd4622f9039fe1bbbb7ffe3151

data/.github/workflows/ci.yaml

@@ -29,6 +29,8 @@ jobs:
         with:
           ruby-version: ${{ matrix.ruby }}
           bundler-cache: true
-      - run: bundle exec rake ci
+      - run: bundle exec rake minitest_old
+      - run: bundle exec rake minitest_functional
+      - run: bundle exec rake rubocop_ci
       - run: bin/srb tc
 

data/.gitignore

@@ -1,3 +1,5 @@
+.DS_Store
+
 /.bundle/
 /.yardoc
 /_yardoc/
@@ -16,3 +18,8 @@
 gemfiles/*.lock
 bin/claude-swarm
 *.gem
+coverage
+
+.dev
+dev.yml
+.shadowenv

data/.rubocop.yml

@@ -1,5 +1,8 @@
 inherit_from: .rubocop_todo.yml
 
+require:
+  - ./rubocop/cop/roast
+
 plugins:
   - rubocop-sorbet
 
@@ -23,3 +26,14 @@ Sorbet/FalseSigil:
   Exclude:
     - "test/**/*"
     - "examples/**/*"
+
+Roast/UseCmdRunner:
+  Enabled: true
+  Exclude:
+    - 'lib/roast/helpers/cmd_runner.rb'
+    - 'roast.gemspec'
+
+Style/MethodCallWithArgsParentheses:
+  Enabled: true
+  Exclude:
+    - 'test/**/*.rb'

data/Gemfile

@@ -16,9 +16,10 @@ gem "mocha"
 gem "rake", require: false
 gem "rubocop-shopify", require: false
 gem "rubocop-sorbet", require: false
+gem "simplecov", require: false
+gem "minitest-rg"
 gem "vcr", require: false
 gem "webmock", require: false
-gem "minitest-rg"
 
 gem "sorbet", require: false
 gem "tapioca", require: false

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    roast-ai (0.4.6)
+    roast-ai (0.4.8)
       activesupport (>= 7.0)
       cli-kit (~> 5.0)
       cli-ui (= 2.3.0)
@@ -50,6 +50,7 @@ GEM
       bigdecimal
       rexml
     diff-lcs (1.6.2)
+    docile (1.4.1)
     dotenv (3.1.8)
     drb (2.2.3)
     dry-configurable (1.3.0)
@@ -214,6 +215,12 @@ GEM
     ruby2_keywords (0.0.5)
     securerandom (0.4.1)
     shellany (0.0.1)
+    simplecov (0.22.0)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.13.2)
+    simplecov_json_formatter (0.1.4)
     sorbet (0.5.12414)
       sorbet-static (= 0.5.12414)
     sorbet-runtime (0.5.12414)
@@ -277,6 +284,7 @@ DEPENDENCIES
   roast-ai!
   rubocop-shopify
   rubocop-sorbet
+  simplecov
   sorbet
   tapioca
   vcr

data/Rakefile

@@ -4,20 +4,32 @@ require "bundler/gem_tasks"
 require "rubocop/rake_task"
 require "rake/testtask"
 
-Rake::TestTask.new(:minitest) do |t|
+Rake::TestTask.new(:minitest_all) do |t|
   t.libs << "test"
   t.libs << "lib"
   t.test_files = FileList["test/**/*_test.rb"]
 end
 
-task test: [:minitest]
+Rake::TestTask.new(:minitest_functional) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/functional/**/*_test.rb"]
+end
 
-RuboCop::RakeTask.new(:rubocop_ci)
+Rake::TestTask.new(:minitest_old) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/functional/**/*_test.rb"]
+end
 
-task ci: [:test, :rubocop_ci]
+task test: [:minitest_all]
+
+RuboCop::RakeTask.new(:rubocop_ci)
 
 RuboCop::RakeTask.new(:rubocop) do |task|
   task.options = ["--autocorrect"]
 end
 
 task default: [:test, :rubocop]
+
+task lint: [:rubocop]

data/examples/README.md

@@ -0,0 +1,9 @@
+These examples demonstrate various usages and features of Roast. They are automatically tested and verified by functional tests (see `test/functional/roast_examples_test.rb`).
+
+### available_tools_demo
+
+Demonstrates use of Roast tool implementations in LLM steps. Steps are implemented with `prompt.md` in directories that match the step name
+
+### basic_prompt_workflow
+
+Demonstrates using LLM steps to glean insights from a provided data file (`test/fixtures/sample_data/skateboard_orders.csv`).

data/examples/available_tools_demo/workflow.yml

@@ -1,4 +1,4 @@
-model: anthropic:claude-opus-4
+model: gpt-4o-mini
 
 tools:
   - Roast::Tools::Grep
@@ -29,4 +29,4 @@ analyze_files:
 write_summary:
   available_tools:
     - write_file
-    - echo
+    - echo

data/examples/basic_prompt_workflow/workflow.md

@@ -0,0 +1 @@
+You are a skateboard shop owner looking for insights on their business.

data/examples/basic_prompt_workflow/workflow.yml

@@ -0,0 +1,14 @@
+name: Analyze My Business
+description: Examines a CSV list of orders for insights
+
+# Default model for all steps
+model: google:gemini-2.5-flash
+tools:
+  - Roast::Tools::ReadFile
+  - Roast::Tools::Grep
+
+steps:
+  - Read the provided CSV files.
+  - "Where are most of my customers from?"
+  - "What is my most popular product?"
+  - Summarize the insights from the report.

data/lib/roast/dsl/executor.rb

@@ -19,7 +19,8 @@ module Roast
       # Define methods to be used in workflows below.
 
       def shell(command_string)
-        puts %x(#{command_string})
+        output, _status = Roast::Helpers::CmdRunner.capture2e(command_string)
+        puts output
       end
     end
   end

data/lib/roast/helpers/cmd_runner.rb

@@ -0,0 +1,199 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  module Helpers
+    class CmdRunner
+      DEFAULT_TIMEOUT = 30
+      MAX_TIMEOUT = 3600 # 1 hour
+
+      @child_processes = {}
+      @child_processes_mutex = Mutex.new
+
+      class << self
+        #: (*untyped, **untyped) -> [String, Process::Status]
+        def capture2(*args, **options)
+          args = args #: as untyped
+          stdout, _stderr, status = capture3(*args, **options)
+          [stdout, status]
+        end
+
+        #: (*untyped, **untyped) -> [String, Process::Status]
+        def capture2e(*args, **options)
+          args = args #: as untyped
+          stdout, stderr, status = capture3(*args, **options)
+          combined_output = stdout + stderr
+          [combined_output, status]
+        end
+
+        #: (*untyped, **untyped) -> [String?, String?, Process::Status?]
+        def capture3(*args, **options)
+          args = args #: as untyped
+          popen3(*args, **options) do |stdin, stdout, stderr, wait_thr|
+            stdin.close # Prevent hanging on stdin-waiting commands
+
+            stdout_thread = threaded_read(stdout)
+            stderr_thread = threaded_read(stderr)
+
+            [stdout_thread.value, stderr_thread.value, wait_thr.value]
+          end
+        end
+
+        #: (*untyped, **untyped) -> bool
+        def system(*args, **options)
+          args = args #: as untyped
+          popen3(*args, **options) do |stdin, stdout, stderr, wait_thr|
+            stdin.close # Prevent hanging on stdin-waiting commands
+
+            stdout_thread = threaded_stream(from: stdout, to: $stdout)
+            stderr_thread = threaded_stream(from: stderr, to: $stderr)
+
+            stdout_thread.join
+            stderr_thread.join
+
+            wait_thr.value.success?
+          end
+        end
+
+        #: (*untyped, **untyped) ?{ (IO, IO, IO, Thread) -> untyped } -> [IO, IO, IO, Thread] | untyped
+        def popen3(*args, **options, &block)
+          args = args #: as untyped
+
+          timeout = options.delete(:timeout)
+          validate_timeout(timeout) unless timeout.nil?
+
+          raise ArgumentError, "Timeout provided but no block given" if !timeout.nil? && !block_given?
+
+          # Mirror Open3.popen3 behavior - if no block, return the IO objects and thread
+          unless block_given?
+            stdin, stdout, stderr, wait_thr = Open3.popen3(*args, **options)
+            track_child_process(wait_thr.pid, presentable_command(args))
+            return [stdin, stdout, stderr, wait_thr]
+          end
+
+          Open3.popen3(*args, **options) do |stdin, stdout, stderr, wait_thr|
+            track_child_process(wait_thr.pid, presentable_command(args))
+
+            runnable = proc { yield(stdin, stdout, stderr, wait_thr) } #: Proc
+            timeout.nil? ? runnable.call : Timeout.timeout(timeout, &runnable)
+          rescue Timeout::Error => e
+            raise e.class, "Command '#{presentable_command(args)}' timed out after #{timeout} seconds: #{e.message}"
+          ensure
+            cleanup_child_process(wait_thr.pid) unless wait_thr.nil?
+          end
+        end
+
+        #: -> void
+        def cleanup_all_children
+          Thread.new do # Thread to avoid issues with calling a mutex in a signal handler
+            child_processes = all_child_processes
+            Thread.current.exit if child_processes.empty?
+
+            child_processes.each do |pid, info|
+              Roast::Helpers::Logger.info("Cleaning up PID #{pid}: #{info[:command]}")
+              cleanup_child_process(pid)
+            end
+          end.join
+        end
+
+        #: (Integer?) -> Integer
+        def normalize_timeout(timeout)
+          return DEFAULT_TIMEOUT if timeout.nil? || timeout <= 0
+
+          [timeout, MAX_TIMEOUT].min
+        end
+
+        private
+
+        #: (Integer) -> void
+        def validate_timeout(timeout)
+          if timeout <= 0 || timeout > MAX_TIMEOUT
+            raise ArgumentError, "Invalid timeout value: #{timeout.inspect}"
+          end
+        end
+
+        #: (Array) -> String
+        def presentable_command(args)
+          args.flatten.map(&:to_s).join(" ")
+        end
+
+        #: (IO) -> Thread
+        def threaded_read(stream)
+          Thread.new do
+            buffer = ""
+            stream.each_line do |line|
+              buffer += line
+            end
+            buffer
+          rescue IOError => e
+            Roast::Helpers::Logger.debug("IOError while capturing output: #{e.message}")
+          end
+        end
+
+        #: (from: IO, to: IO) -> Thread
+        def threaded_stream(from:, to:)
+          Thread.new do
+            from.each_line do |line|
+              to.puts(line)
+            end
+          rescue IOError => e
+            Roast::Helpers::Logger.debug("IOError while streaming output: #{e.message}")
+          end
+        end
+
+        #: (Integer, String) -> void
+        def track_child_process(pid, command)
+          @child_processes_mutex.synchronize do
+            @child_processes[pid] = {
+              command: command,
+              started_at: Time.now,
+            }
+          end
+        end
+
+        #: (Integer) -> void
+        def untrack_child_process(pid)
+          @child_processes_mutex.synchronize { @child_processes.delete(pid) }
+        end
+
+        #: -> Hash[Integer, { command: String, started_at: Time }]
+        def all_child_processes
+          @child_processes_mutex.synchronize { @child_processes.dup }
+        end
+
+        #: (Integer) -> void
+        def cleanup_child_process(pid)
+          untrack_child_process(pid)
+
+          return unless process_running?(pid)
+
+          [0.1, 0.2, 0.5].each do |sleep_time|
+            Process.kill("TERM", pid)
+            break unless process_running?(pid)
+
+            sleep(sleep_time) # Grace period to let the process terminate
+          end
+
+          # Force kill if still alive
+          Process.kill("KILL", pid) if process_running?(pid)
+        rescue Errno::ESRCH
+          # Process already terminated, which is fine
+        rescue Errno::EPERM
+          # Permission denied - process may be owned by different user
+          Roast::Helpers::Logger.debug("Could not kill process #{pid}: Permission denied")
+        rescue => e
+          # Catch any other unexpected errors during cleanup
+          Roast::Helpers::Logger.debug("Unexpected error during process cleanup: #{e.message}")
+        end
+
+        #: (Integer) -> bool
+        def process_running?(pid)
+          Process.getpgid(pid)
+          true
+        rescue Errno::ESRCH
+          false
+        end
+      end
+    end
+  end
+end

data/lib/roast/initializers.rb

@@ -7,7 +7,7 @@ module Roast
       def config_root(starting_path = Dir.pwd, ending_path = File.dirname(Dir.home))
         paths = []
         candidate = starting_path
-        while candidate != ending_path
+        while candidate != ending_path && candidate != "/"
           paths << File.join(candidate, ".roast")
           candidate = File.dirname(candidate)
         end

data/lib/roast/tools/apply_diff.rb

@@ -93,7 +93,7 @@ module Roast
           File.write(temp_file, updated_content)
 
           # Run git diff
-          diff_output = %x(git diff --no-index --no-prefix "#{file_path}" "#{temp_file}" 2>/dev/null)
+          diff_output, _status = Roast::Helpers::CmdRunner.capture2e("git", "diff", "--no-index", "--no-prefix", file_path, temp_file)
 
           if diff_output.empty?
             Roast::Helpers::Logger.info("No differences found (files are identical)\n")

data/lib/roast/tools/bash.rb

@@ -3,7 +3,6 @@
 
 require "English"
 require "roast/helpers/logger"
-require "roast/helpers/timeout_handler"
 
 module Roast
   module Tools
@@ -33,13 +32,14 @@ module Roast
           Roast::Helpers::Logger.warn("⚠️  WARNING: Unrestricted bash execution - use with caution!\n")
         end
 
-        result, exit_status = Roast::Helpers::TimeoutHandler.call(
+        timeout = Roast::Helpers::CmdRunner.normalize_timeout(timeout)
+
+        result, status = Roast::Helpers::CmdRunner.capture2e(
           "#{command} 2>&1",
           timeout: timeout,
-          working_directory: Dir.pwd,
         )
 
-        format_output(command, result, exit_status)
+        format_output(command, result, status.exitstatus)
       rescue Timeout::Error => e
         Roast::Helpers::Logger.error(e.message + "\n")
         e.message

data/lib/roast/tools/cmd.rb

@@ -3,7 +3,6 @@
 
 require "English"
 require "roast/helpers/logger"
-require "roast/helpers/timeout_handler"
 
 module Roast
   module Tools
@@ -140,7 +139,7 @@ module Roast
       end
 
       def execute_command(command, command_prefix, timeout)
-        timeout = Roast::Helpers::TimeoutHandler.validate_timeout(timeout)
+        timeout = Roast::Helpers::CmdRunner.normalize_timeout(timeout)
 
         full_command = if command_prefix == "dev"
           "bash -l -c '#{command.gsub("'", "\\'")}'"
@@ -148,13 +147,12 @@ module Roast
           command
         end
 
-        result, exit_status = Roast::Helpers::TimeoutHandler.call(
+        result, status = Roast::Helpers::CmdRunner.capture2e(
           full_command,
           timeout: timeout,
-          working_directory: Dir.pwd,
         )
 
-        format_output(command, result, exit_status)
+        format_output(command, result, status.exitstatus)
       rescue Timeout::Error => e
         Roast::Helpers::Logger.error(e.message + "\n")
         e.message

data/lib/roast/tools/coding_agent.rb

@@ -105,7 +105,7 @@ module Roast
           command = "cat #{temp_file.path} | #{command_to_run}"
           result = ""
 
-          Open3.popen3(command) do |stdin, stdout, stderr, wait_thread|
+          Roast::Helpers::CmdRunner.popen3(command) do |stdin, stdout, stderr, wait_thread|
             stdin.close
             if expect_json_output
               stdout.each_line do |line|

data/lib/roast/tools/grep.rb

@@ -28,13 +28,17 @@ module Roast
       def call(string)
         Roast::Helpers::Logger.info("🔍 Grepping for string: #{string}\n")
 
-        unless system("command -v rg >/dev/null 2>&1")
+        # Check if ripgrep is available by trying to run it with --version
+        unless Roast::Helpers::CmdRunner.system("rg --version > /dev/null 2>&1")
           raise "ripgrep is not available. Please install it using your package manager (e.g., brew install rg) and make sure it's on your PATH."
         end
 
         # Use Open3 to safely pass the string as an argument, avoiding shell injection
         cmd = ["rg", "-C", "4", "--trim", "--color=never", "--heading", "-F", "--", string, "."]
-        stdout, _stderr, _status = Open3.capture3(*cmd)
+        stdout, stderr, status = Roast::Helpers::CmdRunner.capture3(*cmd)
+        unless status.success?
+          return "Error grepping for string: Command failed: #{stderr}"
+        end
 
         # Limit output to MAX_RESULT_LINES
         lines = stdout.lines

data/lib/roast/tools/read_file.rb

@@ -34,7 +34,8 @@ module Roast
         path = File.expand_path(path)
         Roast::Helpers::Logger.info("📖 Reading file: #{path}\n")
         if File.directory?(path)
-          %x(ls -la #{path})
+          output, _status = Roast::Helpers::CmdRunner.capture2e("ls", "-la", path)
+          output
         else
           File.read(path)
         end

data/lib/roast/tools/swarm.rb

@@ -85,14 +85,9 @@ module Roast
         # Build the swarm command with proper escaping
         command = build_swarm_command(prompt, config_path)
 
-        result = ""
-
         # Execute the command directly with the prompt included
-        IO.popen(command, err: [:child, :out]) do |io|
-          result = io.read
-        end
-
-        exit_status = $CHILD_STATUS.exitstatus
+        result, status = Roast::Helpers::CmdRunner.capture2e(command)
+        exit_status = status.exitstatus
 
         format_output(command, result, exit_status)
       end

data/lib/roast/tools.rb

@@ -1,6 +1,8 @@
 # typed: true
 # frozen_string_literal: true
 
+require "roast/helpers/cmd_runner"
+
 module Roast
   # @requires_ancestor: Kernel
   module Tools
@@ -33,7 +35,14 @@ module Roast
       Signal.trap("INT") do
         puts "\n\nCaught CTRL-C! Printing before exiting:\n"
         puts JSON.pretty_generate(object_to_inspect)
-        exit(1)
+
+        begin
+          Roast::Helpers::CmdRunner.cleanup_all_children
+        rescue => e
+          puts "Error interrupting tracked child processes: #{e.message}"
+        end
+
+        exit(130)
       end
     end
 

data/lib/roast/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Roast
-  VERSION = "0.4.6"
+  VERSION = "0.4.8"
 end

data/lib/roast/workflow/base_step.rb

@@ -10,10 +10,9 @@ module Roast
       delegate :append_to_final_output, :transcript, to: :workflow
       delegate_missing_to :workflow
 
-      # TODO: is this really the model we want to default to, and is this the right place to set it?
-      def initialize(workflow, model: "anthropic:claude-opus-4", name: nil, context_path: nil)
+      def initialize(workflow, model: nil, name: nil, context_path: nil)
         @workflow = workflow
-        @model = model
+        @model = model || workflow.model || StepLoader::DEFAULT_MODEL
         @name = normalize_name(name)
         @context_path = context_path || ContextPathResolver.resolve(self.class)
         @print_response = false

data/lib/roast/workflow/command_executor.rb

@@ -24,14 +24,14 @@ module Roast
       def execute(command_string, exit_on_error: true)
         command = extract_command(command_string)
 
-        output = %x(#{command})
-        exit_status = $CHILD_STATUS.exitstatus
+        output, status = Roast::Helpers::CmdRunner.capture2e(command)
+        exit_status = status.exitstatus
 
         handle_execution_result(
           command: command,
           output: output,
           exit_status: exit_status,
-          success: $CHILD_STATUS.success?,
+          success: status.success?,
           exit_on_error: exit_on_error,
         )
       rescue ArgumentError, CommandExecutionError

data/lib/roast/workflow/resource_resolver.rb

@@ -52,7 +52,7 @@ module Roast
         def process_shell_command(command)
           # If it's a bash command with the $(command) syntax
           if command =~ /^\$\((.*)\)$/
-            return Open3.capture2e({}, ::Regexp.last_match(1).to_s).first.strip
+            return Roast::Helpers::CmdRunner.capture2e({}, ::Regexp.last_match(1).to_s).first.strip
           end
 
           # Not a shell command, return as is

data/lib/roast/workflow/shell_script_step.rb

@@ -48,7 +48,7 @@ module Roast
         log_debug("Executing shell script: #{cmd}")
         log_debug("Environment: #{env.inspect}")
 
-        Open3.capture3(env, cmd, chdir: Dir.pwd)
+        Roast::Helpers::CmdRunner.capture3(env, cmd, chdir: Dir.pwd)
       end
 
       def build_command

data/lib/roast/workflow/step_loader.rb

@@ -208,8 +208,8 @@ module Roast
       def configure_step(step, step_name, is_last_step: nil)
         step_config = config_hash[step_name]
 
-        # Always set the model
-        step.model = determine_model(step_config)
+        # Only set the model if explicitly specified for this step
+        step.model = step_config["model"] if step_config&.key?("model")
 
         # Pass resource to step if supported
         step.resource = workflow.resource if step.respond_to?(:resource=)
@@ -223,11 +223,6 @@ module Roast
         end
       end
 
-      # Determine which model to use for the step
-      def determine_model(step_config)
-        step_config&.dig("model") || config_hash["model"] || DEFAULT_MODEL
-      end
-
       # Apply configuration settings to a step
       def apply_step_configuration(step, step_config)
         step.print_response = step_config["print_response"] if step_config.key?("print_response")