roast-ai 0.3.1 → 0.4.1

data/examples/user_input/workflow.yml

@@ -0,0 +1,73 @@
+name: interactive_deployment
+description: Interactive deployment workflow with user confirmations
+model: gpt-4o
+
+steps:
+  # Collect deployment information
+  - input:
+      prompt: "Which environment do you want to deploy to?"
+      name: environment
+      type: choice
+      options:
+        - development
+        - staging
+        - production
+      required: true
+  
+  - input:
+      prompt: "Enter the deployment tag/version:"
+      name: deploy_tag
+      required: true
+      default: "latest"
+  
+  # Show deployment plan
+  - bash:
+      command: |
+        echo "==================================="
+        echo "       DEPLOYMENT PLAN"
+        echo "==================================="
+        echo "Environment: {{workflow.output.environment}}"
+        echo "Version: {{workflow.output.deploy_tag}}"
+        echo "Timestamp: {{Date.today}}"
+        echo "==================================="
+  
+  # Confirm deployment
+  - input:
+      prompt: "Deploy {{workflow.output.deploy_tag}} to {{workflow.output.environment}}?"
+      type: boolean
+      default: false
+      name: confirm_deploy
+  
+  # Execute deployment if confirmed
+  - if: "{{workflow.output.confirm_deploy}}"
+    then:
+      - bash:
+          command: echo "🚀 Starting deployment to {{workflow.output.environment}}..."
+      
+      # Simulate deployment steps
+      - bash:
+          command: |
+            echo "🚀 Deploying version {{workflow.output.deploy_tag}} to {{workflow.output.environment}}"
+            echo "📦 Pulling Docker image: myapp:{{workflow.output.deploy_tag}}"
+            sleep 2
+            echo "🔄 Rolling out to {{workflow.output.environment}} cluster"
+            sleep 2
+            echo "✅ Deployment completed successfully!"
+      
+      # Post-deployment verification
+      - input:
+          prompt: "Run smoke tests?"
+          type: boolean
+          default: true
+          name: run_tests
+      
+      - if: "{{workflow.output.run_tests}}"
+        then:
+          - bash:
+              command: |
+                echo "🧪 Running smoke tests..."
+                sleep 1
+                echo "✅ All tests passed!"
+    else:
+      - bash:
+          command: echo "❌ Deployment cancelled by user."

data/examples/workflow_generator/create_workflow_files/prompt.md

@@ -15,7 +15,7 @@ Extract the workflow name from the user input JSON and create the workflow in th
 
 Steps to complete:
 
-1. **Create the main directory**: Use Cmd to create the "{{ workflow_name }}" directory
+1. **Create the main directory**: Use Cmd to create the "<%= workflow_name %>" directory
 2. **Create step directories**: Create subdirectories for each workflow step  
 3. **Create workflow.yml**: Write the main workflow configuration file
 4. **Create step prompt files**: Write each step's prompt.md file

data/lib/roast/errors.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
 module Roast
-  # Custom error for API resource not found (404) responses
-  class ResourceNotFoundError < StandardError; end
+  module Errors
+    # Custom error for API resource not found (404) responses
+    class ResourceNotFoundError < StandardError; end
 
-  # Custom error for when API authentication fails
-  class AuthenticationError < StandardError; end
+    # Custom error for when API authentication fails
+    class AuthenticationError < StandardError; end
+  end
 end

data/lib/roast/helpers/function_caching_interceptor.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/helpers/logger"
-
 module Roast
   module Helpers
     # Intercepts function dispatching to add caching capabilities

data/lib/roast/helpers/logger.rb

@@ -1,54 +1,26 @@
 # frozen_string_literal: true
 
-require "logger"
-require "forwardable"
-
 module Roast
   module Helpers
     # Central logger for the Roast application
     class Logger
-      extend Forwardable
       VALID_LOG_LEVELS = ["DEBUG", "INFO", "WARN", "ERROR", "FATAL"].freeze
 
-      attr_reader :logger, :log_level
-
-      # Delegate info and warn methods to the underlying logger
-      def_delegators :logger, :info, :warn
-
-      # Create a specialized debug method that ensures proper functionality
-      def debug(message)
-        logger.debug(message)
-      end
-
-      def error(message)
-        # Add any custom error handling logic here
-        logger.error(message)
-      end
-
-      def fatal(message)
-        # Add any custom fatal error handling logic here
-        logger.fatal(message)
-      end
-
-      def initialize(stdout: $stdout, log_level: ENV["ROAST_LOG_LEVEL"] || "INFO")
-        @log_level = validate_log_level(log_level)
-        @logger = create_logger(stdout)
-      end
+      delegate_missing_to :@logger
 
-      def log_level=(level)
-        @log_level = validate_log_level(level)
-        logger.level = ::Logger.const_get(@log_level)
-      end
+      attr_reader :logger
 
       class << self
-        extend Forwardable
+        delegate_missing_to :instance
 
         def instance
           @instance ||= new
         end
 
-        # Delegate logging methods to the singleton instance
-        def_delegators :instance, :debug, :info, :warn, :error, :fatal
+        # Override Kernel#warn to ensure proper delegation
+        def warn(*args)
+          instance.warn(*args)
+        end
 
         # For testing purposes
         def reset
@@ -58,6 +30,11 @@ module Roast
 
       private
 
+      def initialize(stdout: $stdout, log_level: ENV["ROAST_LOG_LEVEL"] || "INFO")
+        @log_level = validate_log_level(log_level)
+        @logger = create_logger(stdout)
+      end
+
       def validate_log_level(level)
         level_str = level.to_s.upcase
         unless VALID_LOG_LEVELS.include?(level_str)

data/lib/roast/helpers/minitest_coverage_runner.rb

@@ -2,7 +2,6 @@
 
 require "coverage"
 require "minitest"
-require "roast/helpers/logger"
 
 # Disable the built-in `at_exit` hook for Minitest before anything else
 module Minitest

data/lib/roast/helpers/prompt_loader.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "erb"
-
 module Roast
   module Helpers
     class PromptLoader

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/resources/api_resource.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require "json"
-require "net/http"
-require "uri"
-
 module Roast
   module Resources
     # Resource implementation for API endpoints using Fetch API-style format

data/lib/roast/resources/url_resource.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "net/http"
-require "uri"
-
 module Roast
   module Resources
     # Resource implementation for URLs

data/lib/roast/resources.rb

@@ -1,13 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/resources/base_resource"
-require "roast/resources/file_resource"
-require "roast/resources/directory_resource"
-require "roast/resources/url_resource"
-require "roast/resources/api_resource"
-require "roast/resources/none_resource"
-require "uri"
-
 module Roast
   # The Resources module contains classes for handling different types of resources
   # that workflows can operate on. Each resource type implements a common interface.

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/ask_user.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/helpers/logger"
-
 module Roast
   module Tools
     module AskUser

data/lib/roast/tools/bash.rb

@@ -2,6 +2,7 @@
 
 require "English"
 require "roast/helpers/logger"
+require "roast/helpers/timeout_handler"
 
 module Roast
   module Tools
@@ -15,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
@@ -30,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