roast-ai 0.4.0 → 0.4.1

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)

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|
@@ -136,6 +149,48 @@ module Roast
       def claude_code_command
         CodingAgent.configured_command || ENV["CLAUDE_CODE_COMMAND"] || "claude -p --verbose --output-format stream-json"
       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
 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