roast-ai 0.4.0 → 0.4.2

data/examples/no_model_fallback/sample.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# Sample Ruby file for testing interpolation in workflows
+
+class Calculator
+  def initialize
+    @memory = 0
+  end
+
+  def add(number)
+    @memory += number
+  end
+
+  def subtract(number)
+    @memory -= number
+  end
+
+  def multiply(number)
+    @memory *= number
+  end
+
+  def divide(number)
+    raise "Division by zero!" if number.zero?
+
+    @memory /= number
+  end
+
+  attr_reader :memory
+
+  def clear
+    @memory = 0
+  end
+end
+
+# Example usage
+if __FILE__ == $PROGRAM_NAME
+  calc = Calculator.new
+  calc.add(10)
+  calc.multiply(2)
+  calc.subtract(5)
+  puts "Result: #{calc.memory}"
+end

data/examples/no_model_fallback/workflow.yml

@@ -0,0 +1,19 @@
+name: no_model_fallback_example
+
+tools:
+  - Roast::Tools::ReadFile
+
+steps:
+  - analyze_file
+  - analyze_patterns
+  - generate_report_for_{{File.extname(workflow.file).sub('.', '')}}
+  - '$(echo "Processing completed for file: {{File.basename(workflow.file)}}")'
+
+analyze_patterns:
+  json: true
+
+generate_report_for_rb:
+  print_response: true
+
+generate_report_for_md:
+  print_response: true

data/examples/swarm_example.yml

@@ -0,0 +1,25 @@
+name: Swarm Example Workflow
+
+# Example workflow demonstrating Roast's integration with Claude Swarm
+# The Swarm tool is available to the LLM, which can choose to use it when appropriate
+
+tools:
+  - Roast::Tools::Swarm:
+      path: ".swarm.yml"  # Optional - will use default locations if not specified
+
+steps:
+  - orchestrate_refactoring: |
+      Help me refactor this codebase for better performance. Coordinate multiple 
+      Claude agents using the swarm configuration to:
+      1. Analyze the current code structure
+      2. Identify performance bottlenecks
+      3. Implement optimizations
+      4. Ensure backward compatibility
+      
+  - specialized_analysis: |
+      Now use the specialized swarm configuration at ./specialized-swarm.yml to run 
+      a comprehensive code analysis that includes:
+      - Architecture review
+      - Security audit  
+      - Documentation generation
+      - Test coverage analysis

data/lib/roast/errors.rb

@@ -7,5 +7,8 @@ module Roast
 
     # Custom error for when API authentication fails
     class AuthenticationError < StandardError; end
+
+    # Exit the app, for instance via Ctrl-C during an InputStep
+    class ExitEarly < StandardError; end
   end
 end

data/lib/roast/helpers/timeout_handler.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "timeout"
+require "open3"
+
+module Roast
+  module Helpers
+    # Shared timeout handling logic for command-based tools
+    #
+    # This class provides centralized timeout functionality for executing shell commands
+    # with proper process management and resource cleanup.
+    #
+    # @example Basic usage
+    #   output, status = TimeoutHandler.call("echo hello", timeout: 5)
+    #
+    # @example With custom working directory
+    #   output, status = TimeoutHandler.call("pwd", timeout: 10, working_directory: "/tmp")
+    class TimeoutHandler
+      DEFAULT_TIMEOUT = 30
+      MAX_TIMEOUT = 300
+
+      class << self
+        # Execute a command with timeout using Open3 with proper process cleanup
+        # @param command [String] The command to execute
+        # @param timeout [Integer] Timeout in seconds
+        # @param working_directory [String] Directory to execute in (default: Dir.pwd)
+        # @return [Array<String, Integer>] [output, exit_status]
+        # @raise [Timeout::Error] When command exceeds timeout duration
+        def call(command, timeout: DEFAULT_TIMEOUT, working_directory: Dir.pwd)
+          timeout = validate_timeout(timeout)
+          output = ""
+          exit_status = nil
+          wait_thr = nil
+
+          begin
+            Timeout.timeout(timeout) do
+              stdin, stdout, stderr, wait_thr = Open3.popen3(command, chdir: working_directory)
+              stdin.close # Prevent hanging on stdin-waiting commands
+              output = stdout.read + stderr.read
+              wait_thr.join
+              exit_status = wait_thr.value.exitstatus
+
+              [stdout, stderr].each(&:close)
+            end
+          rescue Timeout::Error
+            # Clean up any remaining processes to prevent zombies
+            cleanup_process(wait_thr) if wait_thr&.alive?
+            raise Timeout::Error, "Command '#{command}' in '#{working_directory}' timed out after #{timeout} seconds"
+          end
+
+          [output, exit_status]
+        end
+
+        # Validate and normalize timeout value
+        # @param timeout [Integer, nil] Raw timeout value
+        # @return [Integer] Validated timeout between 1 and MAX_TIMEOUT
+        def validate_timeout(timeout)
+          return DEFAULT_TIMEOUT if timeout.nil? || timeout <= 0
+
+          [timeout, MAX_TIMEOUT].min
+        end
+
+        private
+
+        # Clean up process on timeout to prevent zombie processes
+        # @param wait_thr [Process::Waiter] The process thread to clean up
+        def cleanup_process(wait_thr)
+          return unless wait_thr&.alive?
+
+          pid = wait_thr.pid
+          # First try graceful termination
+          Process.kill("TERM", pid)
+          sleep(0.1)
+
+          # Force kill if still alive
+          if wait_thr.alive?
+            Process.kill("KILL", pid)
+          end
+        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
+      end
+    end
+  end
+end

data/lib/roast/services/context_threshold_checker.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Roast
+  module Services
+    class ContextThresholdChecker
+      # Default max tokens if not specified (128k for GPT-4)
+      DEFAULT_MAX_TOKENS = 128_000
+
+      # Warning threshold as percentage of compaction threshold
+      WARNING_THRESHOLD_RATIO = 0.9
+
+      # Critical threshold as percentage of max tokens
+      CRITICAL_THRESHOLD_RATIO = 0.95
+
+      def should_compact?(token_count, threshold, max_tokens)
+        max_tokens ||= DEFAULT_MAX_TOKENS
+        token_count >= (max_tokens * threshold)
+      end
+
+      def check_warning_threshold(token_count, compaction_threshold, max_tokens)
+        max_tokens ||= DEFAULT_MAX_TOKENS
+        percentage_used = (token_count.to_f / max_tokens * 100).round
+
+        if token_count >= (max_tokens * CRITICAL_THRESHOLD_RATIO)
+          {
+            level: :critical,
+            percentage_used: percentage_used,
+            tokens_used: token_count,
+            max_tokens: max_tokens,
+          }
+        elsif token_count >= (max_tokens * compaction_threshold * WARNING_THRESHOLD_RATIO)
+          {
+            level: :approaching_limit,
+            percentage_used: percentage_used,
+            tokens_used: token_count,
+            max_tokens: max_tokens,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/roast/services/token_counting_service.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Roast
+  module Services
+    class TokenCountingService
+      # Approximate character-to-token ratio for English text
+      # Based on OpenAI's rule of thumb: ~4 characters per token
+      CHARS_PER_TOKEN = 4.0
+
+      # Base token overhead for message structure
+      MESSAGE_OVERHEAD_TOKENS = 3
+
+      def count_messages(messages)
+        return 0 if messages.nil? || messages.empty?
+
+        messages.sum do |message|
+          count_message(message)
+        end
+      end
+
+      private
+
+      def count_message(message)
+        return 0 if message.nil?
+
+        role_tokens = estimate_tokens(message[:role].to_s)
+        content_tokens = estimate_tokens(message[:content].to_s)
+
+        # Don't add overhead for empty messages
+        return 0 if role_tokens == 0 && content_tokens == 0
+
+        # Add overhead for message structure and special tokens
+        role_tokens + content_tokens + MESSAGE_OVERHEAD_TOKENS
+      end
+
+      def estimate_tokens(text)
+        return 0 if text.nil? || text.empty?
+
+        # Simple character-based estimation
+        (text.length / CHARS_PER_TOKEN).ceil
+      end
+    end
+  end
+end

data/lib/roast/tools/apply_diff.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "cli/ui"
+
+module Roast
+  module Tools
+    module ApplyDiff
+      extend self
+
+      class << self
+        def included(base)
+          base.class_eval do
+            function(
+              :apply_diff,
+              "Show a diff to the user and apply changes based on their yes/no response",
+              file_path: { type: "string", description: "Path to the file to modify" },
+              old_content: { type: "string", description: "The current content to be replaced" },
+              new_content: { type: "string", description: "The new content to replace with" },
+              description: { type: "string", description: "Optional description of the change", required: false },
+            ) do |params|
+              Roast::Tools::ApplyDiff.call(
+                params[:file_path],
+                params[:old_content],
+                params[:new_content],
+                params[:description],
+              )
+            end
+          end
+        end
+      end
+
+      def call(file_path, old_content, new_content, description = nil)
+        unless File.exist?(file_path)
+          error_msg = "File not found: #{file_path}"
+          Roast::Helpers::Logger.error(error_msg + "\n")
+          return error_msg
+        end
+
+        current_content = File.read(file_path)
+        unless current_content.include?(old_content)
+          error_msg = "Old content not found in file: #{file_path}"
+          Roast::Helpers::Logger.error(error_msg + "\n")
+          return error_msg
+        end
+
+        # Show the diff
+        show_diff(file_path, old_content, new_content, description)
+
+        # Ask for confirmation
+        prompt_text = "Apply this change? (y/n)"
+        response = ::CLI::UI::Prompt.ask(prompt_text)
+
+        if response.to_s.downcase.start_with?("y")
+          # Apply the change
+          updated_content = current_content.gsub(old_content, new_content)
+          File.write(file_path, updated_content)
+
+          success_msg = "✅ Changes applied to #{file_path}"
+          Roast::Helpers::Logger.info(success_msg + "\n")
+          success_msg
+        else
+          cancel_msg = "❌ Changes cancelled for #{file_path}"
+          Roast::Helpers::Logger.info(cancel_msg + "\n")
+          cancel_msg
+        end
+      rescue StandardError => e
+        error_message = "Error applying diff: #{e.message}"
+        Roast::Helpers::Logger.error(error_message + "\n")
+        Roast::Helpers::Logger.debug(e.backtrace.join("\n") + "\n") if ENV["DEBUG"]
+        error_message
+      end
+
+      private
+
+      def show_diff(file_path, old_content, new_content, description)
+        require "tmpdir"
+
+        Roast::Helpers::Logger.info("📝 Proposed change for #{file_path}:\n")
+
+        if description
+          Roast::Helpers::Logger.info("Description: #{description}\n\n")
+        end
+
+        # Create temporary files for git diff
+        Dir.mktmpdir do |tmpdir|
+          # Write current content with old_content replaced by new_content
+          current_content = File.read(file_path)
+          updated_content = current_content.gsub(old_content, new_content)
+
+          # Create temp file with the proposed changes
+          temp_file = File.join(tmpdir, File.basename(file_path))
+          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)
+
+          if diff_output.empty?
+            Roast::Helpers::Logger.info("No differences found (files are identical)\n")
+          else
+            # Clean up the diff output - remove temp file paths and use relative paths with colors
+            cleaned_diff = diff_output.lines.map do |line|
+              case line
+              when /^diff --git /
+                ::CLI::UI.fmt("{{bold:diff --git a/#{file_path} b/#{file_path}}}")
+              when /^--- /
+                ::CLI::UI.fmt("{{red:--- a/#{file_path}}}")
+              when /^\+\+\+ /
+                ::CLI::UI.fmt("{{green:+++ b/#{file_path}}}")
+              when /^@@/
+                ::CLI::UI.fmt("{{cyan:#{line.chomp}}}")
+              when /^-/
+                ::CLI::UI.fmt("{{red:#{line.chomp}}}")
+              when /^\+/
+                ::CLI::UI.fmt("{{green:#{line.chomp}}}")
+              else
+                line.chomp
+              end
+            end.join("\n")
+
+            Roast::Helpers::Logger.info("#{cleaned_diff}\n")
+          end
+        end
+
+        Roast::Helpers::Logger.info("\n")
+      end
+    end
+  end
+end

data/lib/roast/tools/bash.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require "English"
+require "roast/helpers/logger"
+require "roast/helpers/timeout_handler"
+
 module Roast
   module Tools
     module Bash
@@ -12,14 +16,15 @@ module Roast
               :bash,
               "Execute any bash command without restrictions. ⚠️ WARNING: Use only in trusted environments!",
               command: { type: "string", description: "The bash command to execute" },
+              timeout: { type: "integer", description: "Timeout in seconds (optional, default: 30)", required: false },
             ) do |params|
-              Roast::Tools::Bash.call(params[:command])
+              Roast::Tools::Bash.call(params[:command], timeout: params[:timeout])
             end
           end
         end
       end
 
-      def call(command)
+      def call(command, timeout: 30)
         Roast::Helpers::Logger.info("🚀 Executing bash command: #{command}\n")
 
         # Show warning unless explicitly disabled
@@ -27,15 +32,16 @@ module Roast
           Roast::Helpers::Logger.warn("⚠️  WARNING: Unrestricted bash execution - use with caution!\n")
         end
 
-        # Execute the command without any restrictions
-        result = ""
-        IO.popen("#{command} 2>&1", chdir: Dir.pwd) do |io|
-          result = io.read
-        end
-
-        exit_status = $CHILD_STATUS.exitstatus
+        result, exit_status = Roast::Helpers::TimeoutHandler.call(
+          "#{command} 2>&1",
+          timeout: timeout,
+          working_directory: Dir.pwd,
+        )
 
         format_output(command, result, exit_status)
+      rescue Timeout::Error => e
+        Roast::Helpers::Logger.error(e.message + "\n")
+        e.message
       rescue StandardError => e
         handle_error(e)
       end

data/lib/roast/tools/cmd.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require "English"
+require "roast/helpers/logger"
+require "roast/helpers/timeout_handler"
+
 module Roast
   module Tools
     module Cmd
@@ -62,6 +66,11 @@ module Roast
                 description: "Arguments to pass to the #{command} command",
                 required: false,
               },
+              timeout: {
+                type: "integer",
+                description: "Timeout in seconds (optional, default: 30)",
+                required: false,
+              },
             ) do |params|
               full_command = if params[:args].nil? || params[:args].empty?
                 command
@@ -69,7 +78,7 @@ module Roast
                 "#{command} #{params[:args]}"
               end
 
-              Roast::Tools::Cmd.execute_allowed_command(full_command, command)
+              Roast::Tools::Cmd.execute_allowed_command(full_command, command, params[:timeout])
             end
           end
         end
@@ -80,15 +89,16 @@ module Roast
         end
       end
 
-      def execute_allowed_command(full_command, command_prefix)
+      def execute_allowed_command(full_command, command_prefix, timeout = 30)
         Roast::Helpers::Logger.info("🔧 Running command: #{full_command}\n")
-        execute_command(full_command, command_prefix)
+
+        execute_command(full_command, command_prefix, timeout)
       rescue StandardError => e
         handle_error(e)
       end
 
       # Legacy method for backward compatibility
-      def call(command, config = {})
+      def call(command, config = {}, timeout: 30)
         Roast::Helpers::Logger.info("🔧 Running command: #{command}\n")
 
         allowed_commands = config[CONFIG_ALLOWED_COMMANDS] || DEFAULT_ALLOWED_COMMANDS
@@ -96,7 +106,8 @@ module Roast
         return validation_result unless validation_result.nil?
 
         command_prefix = command.split(" ").first
-        execute_command(command, command_prefix)
+
+        execute_command(command, command_prefix, timeout)
       rescue StandardError => e
         handle_error(e)
       end
@@ -127,16 +138,25 @@ module Roast
         configuration&.tool_config("Roast::Tools::Cmd") || {}
       end
 
-      def execute_command(command, command_prefix)
-        result = if command_prefix == "dev"
-          # Use bash -l -c to ensure we get a login shell with all environment variables
-          full_command = "bash -l -c '#{command.gsub("'", "\\'")}'"
-          IO.popen(full_command, chdir: Dir.pwd, &:read)
+      def execute_command(command, command_prefix, timeout)
+        timeout = Roast::Helpers::TimeoutHandler.validate_timeout(timeout)
+
+        full_command = if command_prefix == "dev"
+          "bash -l -c '#{command.gsub("'", "\\'")}'"
         else
-          IO.popen(command, chdir: Dir.pwd, &:read)
+          command
         end
 
-        format_output(command, result, $CHILD_STATUS.exitstatus)
+        result, exit_status = Roast::Helpers::TimeoutHandler.call(
+          full_command,
+          timeout: timeout,
+          working_directory: Dir.pwd,
+        )
+
+        format_output(command, result, exit_status)
+      rescue Timeout::Error => e
+        Roast::Helpers::Logger.error(e.message + "\n")
+        e.message
       end
 
       def format_output(command, result, exit_status)