roast-ai 0.4.0 → 0.4.2

data/lib/roast/tools/coding_agent.rb

@@ -19,10 +19,16 @@ module Roast
           base.class_eval do
             function(
               :coding_agent,
-              "AI-powered coding agent that runs Claude Code CLI with the given prompt",
+              "AI-powered coding agent that runs an instance of the Claude Code agent with the given prompt. If the agent is iterating on previous work, set continue to true.",
               prompt: { type: "string", description: "The prompt to send to Claude Code" },
+              include_context_summary: { type: "boolean", description: "Whether to set a summary of the current workflow context as system directive (default: false)", required: false },
+              continue: { type: "boolean", description: "Whether to continue where the previous coding agent left off or start with a fresh context (default: false, start fresh)", required: false },
             ) do |params|
-              Roast::Tools::CodingAgent.call(params[:prompt])
+              Roast::Tools::CodingAgent.call(
+                params[:prompt],
+                include_context_summary: params[:include_context_summary].presence || false,
+                continue: params[:continue].presence || false,
+              )
             end
           end
         end
@@ -33,9 +39,9 @@ module Roast
         end
       end
 
-      def call(prompt)
+      def call(prompt, include_context_summary: false, continue: false)
         Roast::Helpers::Logger.info("🤖 Running CodingAgent\n")
-        run_claude_code(prompt)
+        run_claude_code(prompt, include_context_summary:, continue:)
       rescue StandardError => e
         "Error running CodingAgent: #{e.message}".tap do |error_message|
           Roast::Helpers::Logger.error(error_message + "\n")
@@ -45,7 +51,7 @@ module Roast
 
       private
 
-      def run_claude_code(prompt)
+      def run_claude_code(prompt, include_context_summary:, continue:)
         Roast::Helpers::Logger.debug("🤖 Executing Claude Code CLI with prompt: #{prompt}\n")
 
         # Create a temporary file with a unique name
@@ -55,14 +61,21 @@ module Roast
         temp_file = Tempfile.new(["claude_prompt_#{timestamp}_#{pid}_#{random_id}", ".txt"])
 
         begin
+          # Prepare the final prompt with context summary if requested
+          final_prompt = prepare_prompt(prompt, include_context_summary)
+
           # Write the prompt to the file
-          temp_file.write(prompt)
+          temp_file.write(final_prompt)
           temp_file.close
 
+          # Build the command with continue option if specified
+          base_command = claude_code_command
+          command_to_run = build_command(base_command, continue:)
+
           # Run Claude Code CLI using the temp file as input with streaming output
-          expect_json_output = claude_code_command.include?("--output-format stream-json") ||
-            claude_code_command.include?("--output-format json")
-          command = "cat #{temp_file.path} | #{claude_code_command}"
+          expect_json_output = command_to_run.include?("--output-format stream-json") ||
+            command_to_run.include?("--output-format json")
+          command = "cat #{temp_file.path} | #{command_to_run}"
           result = ""
 
           Open3.popen3(command) do |stdin, stdout, stderr, wait_thread|
@@ -134,7 +147,49 @@ module Roast
       end
 
       def claude_code_command
-        CodingAgent.configured_command || ENV["CLAUDE_CODE_COMMAND"] || "claude -p --verbose --output-format stream-json"
+        CodingAgent.configured_command || ENV["CLAUDE_CODE_COMMAND"] || "claude -p --verbose --output-format stream-json --dangerously-skip-permissions"
+      end
+
+      def build_command(base_command, continue:)
+        return base_command unless continue
+
+        # Add --continue flag to the command
+        # If the command already has flags, insert --continue after 'claude'
+        if base_command.start_with?("claude ")
+          base_command.sub("claude ", "claude --continue ")
+        else
+          # Fallback for non-standard commands
+          "#{base_command} --continue"
+        end
+      end
+
+      def prepare_prompt(prompt, include_context_summary)
+        return prompt unless include_context_summary
+
+        context_summary = generate_context_summary(prompt)
+        return prompt if context_summary.blank? || context_summary == "No relevant information found in the workflow context."
+
+        # Prepend context summary as a system directive
+        <<~PROMPT
+          <system>
+          #{context_summary}
+          </system>
+
+          #{prompt}
+        PROMPT
+      end
+
+      def generate_context_summary(agent_prompt)
+        # Access the current workflow context if available
+        workflow_context = Thread.current[:workflow_context]
+        return unless workflow_context
+
+        # Use ContextSummarizer to generate an intelligent summary
+        summarizer = ContextSummarizer.new
+        summarizer.generate_summary(workflow_context, agent_prompt)
+      rescue => e
+        Roast::Helpers::Logger.debug("Failed to generate context summary: #{e.message}\n")
+        nil
       end
     end
   end

data/lib/roast/tools/context_summarizer.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Roast
+  module Tools
+    class ContextSummarizer
+      include Raix::ChatCompletion
+
+      attr_reader :model
+
+      def initialize(model: "o4-mini")
+        @model = model
+      end
+
+      # Generate an intelligent summary of the workflow context
+      # tailored to what the agent needs to know for its upcoming task
+      #
+      # @param workflow_context [Object] The workflow context from Thread.current
+      # @param agent_prompt [String] The prompt the agent is about to execute
+      # @return [String, nil] The generated summary or nil if generation fails
+      def generate_summary(workflow_context, agent_prompt)
+        return unless workflow_context&.workflow
+
+        context_data = build_context_data(workflow_context.workflow)
+        summary_prompt = build_summary_prompt(context_data, agent_prompt)
+
+        # Use our own transcript for the summary generation
+        self.transcript = []
+        prompt(summary_prompt)
+
+        result = chat_completion
+        result&.strip
+      rescue => e
+        Roast::Helpers::Logger.debug("Failed to generate LLM context summary: #{e.message}\n")
+        nil
+      end
+
+      private
+
+      def build_context_data(workflow)
+        data = {}
+
+        # Add workflow description if available
+        if workflow.config && workflow.config["description"]
+          data[:workflow_description] = workflow.config["description"]
+        end
+
+        # Add step outputs if available
+        if workflow.output && !workflow.output.empty?
+          data[:step_outputs] = workflow.output.map do |step_name, output|
+            # Include full output for context generation
+            { step: step_name, output: output }
+          end
+        end
+
+        # Add current working directory
+        data[:working_directory] = Dir.pwd
+
+        # Add workflow name if available
+        if workflow.respond_to?(:name)
+          data[:workflow_name] = workflow.name
+        end
+
+        data
+      end
+
+      def build_summary_prompt(context_data, agent_prompt)
+        prompt_parts = []
+
+        prompt_parts << "You are preparing a context summary for an AI coding agent (Claude Code) that is about to perform a task."
+        prompt_parts << "\nThe agent's upcoming task is:"
+        prompt_parts << "```"
+        prompt_parts << agent_prompt
+        prompt_parts << "```"
+
+        prompt_parts << "\nBased on the following workflow context, provide a concise summary of ONLY the information that would be relevant for the agent to complete this specific task."
+
+        if context_data[:workflow_description]
+          prompt_parts << "\nWorkflow Description: #{context_data[:workflow_description]}"
+        end
+
+        if context_data[:workflow_name]
+          prompt_parts << "\nWorkflow Name: #{context_data[:workflow_name]}"
+        end
+
+        if context_data[:working_directory]
+          prompt_parts << "\nWorking Directory: #{context_data[:working_directory]}"
+        end
+
+        if context_data[:step_outputs] && !context_data[:step_outputs].empty?
+          prompt_parts << "\nPrevious Step Outputs:"
+          context_data[:step_outputs].each do |step_data|
+            prompt_parts << "\n### Step: #{step_data[:step]}"
+            prompt_parts << "Output: #{step_data[:output]}"
+          end
+        end
+
+        prompt_parts << "\n\nGenerate a brief context summary that:"
+        prompt_parts << "1. Focuses ONLY on information relevant to the agent's upcoming task"
+        prompt_parts << "2. Highlights key findings, decisions, or outputs the agent should be aware of"
+        prompt_parts << "3. Is concise and actionable (aim for 3-5 sentences)"
+        prompt_parts << "4. Does not repeat information that would be obvious from the agent's prompt"
+        prompt_parts << "\nIf there is no relevant context for this task, respond with 'No relevant information found in the workflow context.'"
+
+        prompt_parts.join("\n")
+      end
+    end
+  end
+end

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.2"
 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/command_executor.rb

@@ -14,6 +14,8 @@ module Roast
         end
       end
 
+      BASH_COMMAND_REGEX = /^\$\((.*)\)$/m
+
       def initialize(logger: nil)
         @logger = logger || NullLogger.new
       end
@@ -44,7 +46,7 @@ module Roast
       private
 
       def extract_command(command_string)
-        match = command_string.strip.match(/^\$\((.*)\)$/)
+        match = command_string.strip.match(BASH_COMMAND_REGEX)
         raise ArgumentError, "Invalid command format. Expected $(command), got: #{command_string}" unless match
 
         match[1]

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

@@ -38,6 +38,8 @@ module Roast
         else
           @workflow_runner.run_targetless
         end
+      rescue Roast::Errors::ExitEarly
+        $stderr.puts "Exiting workflow early."
       ensure
         execution_time = Time.now - start_time