roast-ai 0.4.0 → 0.4.1

data/lib/roast/tools/swarm.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "shellwords"
+
+module Roast
+  module Tools
+    module Swarm
+      extend self
+
+      DEFAULT_CONFIG_PATHS = [
+        ".swarm.yml",
+        "swarm.yml",
+        ".swarm/config.yml",
+      ].freeze
+
+      CONFIG_PATH_KEY = "path"
+      private_constant :DEFAULT_CONFIG_PATHS, :CONFIG_PATH_KEY
+
+      class << self
+        def included(base)
+          base.class_eval do
+            function(
+              :swarm,
+              "Execute Claude Swarm to orchestrate multiple Claude Code instances",
+              prompt: {
+                type: "string",
+                description: "The prompt to send to the swarm agents",
+                required: true,
+              },
+              path: {
+                type: "string",
+                description: "Path to the swarm configuration file (optional)",
+                required: false,
+              },
+            ) do |params|
+              Roast::Tools::Swarm.call(params[:prompt], params[:path])
+            end
+          end
+        end
+
+        def post_configuration_setup(base, config = {})
+          @tool_config = config
+        end
+
+        attr_reader :tool_config
+      end
+
+      def call(prompt, step_path = nil)
+        config_path = determine_config_path(step_path)
+
+        if config_path.nil?
+          return "Error: No swarm configuration file found. Please create a .swarm.yml file or specify a path."
+        end
+
+        unless File.exist?(config_path)
+          return "Error: Swarm configuration file not found at: #{config_path}"
+        end
+
+        Roast::Helpers::Logger.info("🐝 Running Claude Swarm with config: #{config_path}\n")
+
+        execute_swarm(prompt, config_path)
+      rescue StandardError => e
+        handle_error(e)
+      end
+
+      private
+
+      def determine_config_path(step_path)
+        # Priority: step-level path > tool-level path > default locations
+
+        # 1. Check step-level path
+        return step_path if step_path
+
+        # 2. Check tool-level path from configuration
+        if tool_config && tool_config[CONFIG_PATH_KEY]
+          return tool_config[CONFIG_PATH_KEY]
+        end
+
+        # 3. Check default locations
+        DEFAULT_CONFIG_PATHS.find { |path| File.exist?(path) }
+      end
+
+      def execute_swarm(prompt, config_path)
+        # 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
+
+        format_output(command, result, exit_status)
+      end
+
+      def build_swarm_command(prompt, config_path)
+        # Build the claude-swarm command with properly escaped arguments
+        [
+          "claude-swarm",
+          "--config",
+          config_path,
+          "--prompt",
+          prompt,
+        ].shelljoin
+      end
+
+      def format_output(command, result, exit_status)
+        "Command: #{command}\n" \
+          "Exit status: #{exit_status}\n" \
+          "Output:\n#{result}"
+      end
+
+      def handle_error(error)
+        error_message = "Error running swarm: #{error.message}"
+        Roast::Helpers::Logger.error("#{error_message}\n")
+        Roast::Helpers::Logger.debug("#{error.backtrace.join("\n")}\n") if ENV["DEBUG"]
+        error_message
+      end
+    end
+  end
+end

data/lib/roast/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Roast
-  VERSION = "0.4.0"
+  VERSION = "0.4.1"
 end

data/lib/roast/workflow/agent_step.rb

@@ -12,8 +12,15 @@ module Roast
           read_sidecar_prompt
         end
 
-        # Call CodingAgent directly with the prompt content
-        result = Roast::Tools::CodingAgent.call(prompt_content)
+        # Extract agent-specific configuration from workflow config
+        step_config = workflow.config[name.to_s] || {}
+        agent_options = {
+          include_context_summary: step_config.fetch("include_context_summary", false),
+          continue: step_config.fetch("continue", false),
+        }
+
+        # Call CodingAgent directly with the prompt content and options
+        result = Roast::Tools::CodingAgent.call(prompt_content, **agent_options)
 
         # Process output if print_response is enabled
         process_output(result, print_response:)

data/lib/roast/workflow/base_iteration_step.rb

@@ -65,10 +65,11 @@ module Roast
         executor ||= WorkflowExecutor.new(context, config_hash, context_path)
         results = []
 
-        steps.each do |step|
+        steps.each_with_index do |step, index|
+          is_last_step = (index == steps.length - 1)
           result = case step
           when String
-            executor.execute_step(step)
+            executor.execute_step(step, is_last_step:)
           when Hash, Array
             executor.execute_steps([step])
           end

data/lib/roast/workflow/base_workflow.rb

@@ -16,9 +16,11 @@ module Roast
         :session_name,
         :session_timestamp,
         :model,
-        :workflow_configuration
+        :workflow_configuration,
+        :storage_type,
+        :context_management_config
 
-      attr_reader :pre_processing_data
+      attr_reader :pre_processing_data, :context_manager
 
       delegate :api_provider, :openai?, to: :workflow_configuration, allow_nil: true
       delegate :output, :output=, :append_to_final_output, :final_output, to: :output_manager
@@ -36,6 +38,8 @@ module Roast
 
         # Initialize managers
         @output_manager = OutputManager.new
+        @context_manager = ContextManager.new
+        @context_management_config = {}
 
         # Setup prompt and handlers
         read_sidecar_prompt.then do |prompt|
@@ -53,22 +57,48 @@ module Roast
         step_model = kwargs[:model]
 
         with_model(step_model) do
+          # Configure context manager if needed
+          if @context_management_config.any?
+            @context_manager.configure(@context_management_config)
+          end
+
+          # Track token usage before API call
+          messages = kwargs[:messages] || transcript.flatten.compact
+          if @context_management_config[:enabled]
+            @context_manager.track_usage(messages)
+            @context_manager.check_warnings
+          end
+
           ActiveSupport::Notifications.instrument("roast.chat_completion.start", {
             model: model,
             parameters: kwargs.except(:openai, :model),
           })
 
+          # Clear any previous response
+          Thread.current[:chat_completion_response] = nil
+
           # Call the parent module's chat_completion
           # skip model because it is read directly from the model method
           result = super(**kwargs.except(:model))
           execution_time = Time.now - start_time
 
+          # Extract token usage from the raw response stored by Raix
+          raw_response = Thread.current[:chat_completion_response]
+          token_usage = extract_token_usage(raw_response) if raw_response
+
+          # Update context manager with actual token usage if available
+          if token_usage && @context_management_config[:enabled]
+            actual_total = token_usage.dig("total_tokens") || token_usage.dig(:total_tokens)
+            @context_manager.update_with_actual_usage(actual_total) if actual_total
+          end
+
           ActiveSupport::Notifications.instrument("roast.chat_completion.complete", {
             success: true,
             model: model,
             parameters: kwargs.except(:openai, :model),
             execution_time: execution_time,
             response_size: result.to_s.length,
+            token_usage: token_usage,
           })
           result
         end
@@ -115,6 +145,15 @@ module Roast
       def read_sidecar_prompt
         Roast::Helpers::PromptLoader.load_prompt(self, file)
       end
+
+      def extract_token_usage(result)
+        # Token usage is typically in the response metadata
+        # This depends on the API provider's response format
+        return unless result.is_a?(Hash) || result.respond_to?(:to_h)
+
+        result_hash = result.is_a?(Hash) ? result : result.to_h
+        result_hash.dig("usage") || result_hash.dig(:usage)
+      end
     end
   end
 end

data/lib/roast/workflow/configuration.rb

@@ -7,7 +7,7 @@ module Roast
     class Configuration
       MCPTool = Struct.new(:name, :config, :only, :except, keyword_init: true)
 
-      attr_reader :config_hash, :workflow_path, :name, :steps, :pre_processing, :post_processing, :tools, :tool_configs, :mcp_tools, :function_configs, :model, :resource
+      attr_reader :config_hash, :workflow_path, :name, :steps, :pre_processing, :post_processing, :tools, :tool_configs, :mcp_tools, :function_configs, :model, :resource, :context_management
       attr_accessor :target
 
       delegate :api_provider, :openrouter?, :openai?, :uri_base, to: :api_configuration
@@ -32,6 +32,7 @@ module Roast
         @mcp_tools = ConfigurationLoader.extract_mcp_tools(@config_hash)
         @function_configs = ConfigurationLoader.extract_functions(@config_hash)
         @model = ConfigurationLoader.extract_model(@config_hash)
+        @context_management = ConfigurationLoader.extract_context_management(@config_hash)
 
         # Initialize components
         @api_configuration = ApiConfiguration.new(@config_hash)

data/lib/roast/workflow/configuration_loader.rb

@@ -8,7 +8,7 @@ module Roast
         # Load configuration from a YAML file
         # @param workflow_path [String] Path to the workflow YAML file
         # @return [Hash] The parsed configuration hash
-        def load(workflow_path)
+        def load(workflow_path, options = {})
           validate_path!(workflow_path)
 
           # Load shared.yml if it exists one level above
@@ -23,6 +23,18 @@ module Roast
           end
 
           yaml_content += File.read(workflow_path)
+
+          # Use comprehensive validation if requested
+          if options[:comprehensive_validation]
+            validator = Validators::ValidationOrchestrator.new(yaml_content, workflow_path)
+            unless validator.valid?
+              raise_validation_errors(validator)
+            end
+
+            # Show warnings if any
+            display_warnings(validator.warnings) if validator.warnings.any?
+          end
+
           config_hash = YAML.load(yaml_content, aliases: true)
 
           validate_config!(config_hash)
@@ -132,6 +144,30 @@ module Roast
           options[:target] || config_hash["target"]
         end
 
+        # Extract context management configuration
+        # @param config_hash [Hash] The configuration hash
+        # @return [Hash] The context management configuration with defaults
+        def extract_context_management(config_hash)
+          default_config = {
+            enabled: true,
+            strategy: "auto",
+            threshold: 0.8,
+            max_tokens: nil,
+            retain_steps: [],
+          }
+
+          return default_config unless config_hash["context_management"].is_a?(Hash)
+
+          config = config_hash["context_management"]
+          {
+            enabled: config.fetch("enabled", default_config[:enabled]),
+            strategy: config.fetch("strategy", default_config[:strategy]),
+            threshold: config.fetch("threshold", default_config[:threshold]),
+            max_tokens: config["max_tokens"],
+            retain_steps: config.fetch("retain_steps", default_config[:retain_steps]),
+          }
+        end
+
         private
 
         def validate_path!(workflow_path)
@@ -143,6 +179,32 @@ module Roast
         def validate_config!(config_hash)
           raise ArgumentError, "Invalid workflow configuration" unless config_hash.is_a?(Hash)
         end
+
+        def raise_validation_errors(validator)
+          error_messages = validator.errors.map do |error|
+            message = "• #{error[:message]}"
+            message += " (#{error[:suggestion]})" if error[:suggestion]
+            message
+          end.join("\n")
+
+          raise CLI::Kit::Abort, <<~ERROR
+            Workflow validation failed with #{validator.errors.size} error(s):
+
+            #{error_messages}
+          ERROR
+        end
+
+        def display_warnings(warnings)
+          return if warnings.empty?
+
+          ::CLI::UI::Frame.open("Validation Warnings", color: :yellow) do
+            warnings.each do |warning|
+              puts ::CLI::UI.fmt("{{yellow:#{warning[:message]}}}")
+              puts ::CLI::UI.fmt("  {{gray:→ #{warning[:suggestion]}}}") if warning[:suggestion]
+              puts
+            end
+          end
+        end
       end
     end
   end

data/lib/roast/workflow/context_manager.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    class ContextManager
+      attr_reader :total_tokens
+
+      def initialize(token_counter: nil, threshold_checker: nil)
+        @token_counter = token_counter || Services::TokenCountingService.new
+        @threshold_checker = threshold_checker || Services::ContextThresholdChecker.new
+        @total_tokens = 0
+        @message_count = 0
+        @config = default_config
+        @last_actual_update = nil
+        @estimated_tokens_since_update = 0
+      end
+
+      def configure(config)
+        @config = default_config.merge(config)
+      end
+
+      def track_usage(messages)
+        current_tokens = @token_counter.count_messages(messages)
+        @total_tokens += current_tokens
+        @message_count += messages.size
+
+        {
+          current_tokens: current_tokens,
+          total_tokens: @total_tokens,
+        }
+      end
+
+      def should_compact?(token_count = @total_tokens)
+        return false unless @config[:enabled]
+
+        @threshold_checker.should_compact?(
+          token_count,
+          @config[:threshold],
+          @config[:max_tokens],
+        )
+      end
+
+      def check_warnings(token_count = @total_tokens)
+        return unless @config[:enabled]
+
+        warning = @threshold_checker.check_warning_threshold(
+          token_count,
+          @config[:threshold],
+          @config[:max_tokens],
+        )
+
+        if warning
+          ActiveSupport::Notifications.instrument("roast.context_warning", warning)
+        end
+      end
+
+      def reset
+        @total_tokens = 0
+        @message_count = 0
+      end
+
+      def statistics
+        {
+          total_tokens: @total_tokens,
+          message_count: @message_count,
+          average_tokens_per_message: @message_count > 0 ? @total_tokens / @message_count : 0,
+        }
+      end
+
+      def update_with_actual_usage(actual_total)
+        return unless actual_total && actual_total > 0
+
+        @total_tokens = actual_total
+        @last_actual_update = Time.now
+        @estimated_tokens_since_update = 0
+      end
+
+      private
+
+      def default_config
+        {
+          enabled: true,
+          threshold: 0.8,
+          max_tokens: nil, # Will use default from threshold checker
+        }
+      end
+    end
+  end
+end

data/lib/roast/workflow/each_step.rb

@@ -65,7 +65,7 @@ module Roast
       end
 
       def save_iteration_state(index, item)
-        state_repository = FileStateRepository.new
+        state_repository = StateRepositoryFactory.create(workflow.storage_type)
 
         # Save the current iteration state
         state_data = {

data/lib/roast/workflow/output_handler.rb

@@ -11,7 +11,7 @@ module Roast
           final_output = workflow.final_output.to_s
           return if final_output.empty?
 
-          state_repository = FileStateRepository.new
+          state_repository = StateRepositoryFactory.create(workflow.storage_type)
           output_file = state_repository.save_final_output(workflow, final_output)
           $stderr.puts "Final output saved to: #{output_file}" if output_file
         rescue => e

data/lib/roast/workflow/repeat_step.rb

@@ -55,7 +55,7 @@ module Roast
       private
 
       def save_iteration_state(iteration)
-        state_repository = FileStateRepository.new
+        state_repository = StateRepositoryFactory.create(workflow.storage_type)
 
         # Save the current iteration count in the state
         state_data = {

data/lib/roast/workflow/replay_handler.rb

@@ -9,7 +9,7 @@ module Roast
 
       def initialize(workflow, state_repository: nil)
         @workflow = workflow
-        @state_repository = state_repository || FileStateRepository.new
+        @state_repository = state_repository || StateRepositoryFactory.create(workflow.storage_type)
         @processed = false
       end