roast-ai 0.1.0

data/lib/roast/helpers/minitest_coverage_runner.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+require "coverage"
+require "minitest"
+require_relative "logger"
+
+# Disable the built-in `at_exit` hook for Minitest before anything else
+module Minitest
+  class << self
+    alias_method :original_at_exit, :at_exit
+    def at_exit(*)
+      # Do nothing to prevent autorun hooks
+    end
+  end
+end
+
+module Roast
+  module Helpers
+    class TestStatsCollector
+      attr_reader :tests_count, :assertions_count
+
+      def initialize
+        @tests_count = 0
+        @assertions_count = 0
+
+        # Install our hook into Minitest's before and after hooks
+        Minitest.after_run { @reported = true }
+
+        # Install a custom hook to count tests
+        Minitest::Test.class_eval do
+          original_run = instance_method(:run)
+
+          define_method(:run) do |*args|
+            result = original_run.bind(self).call(*args)
+            TestStatsCollector.instance.count_test(result)
+            result
+          end
+        end
+      end
+
+      def count_test(result)
+        @tests_count += 1
+        @assertions_count += result.assertions
+      end
+
+      class << self
+        def instance
+          @instance ||= new
+        end
+      end
+    end
+
+    class MinitestCoverageRunner
+      def initialize(test_file_path, subject_file_path)
+        @test_file = File.expand_path(test_file_path)
+        @subject_file = File.expand_path(subject_file_path)
+
+        # Detect Rails vs Gem by checking for config/environment.rb or a .gemspec
+        @rails_app   = File.exist?(File.join(Dir.pwd, "config", "environment.rb"))
+        @gem_project = Dir.glob(File.join(Dir.pwd, "*.gemspec")).any?
+      end
+
+      def run
+        # Make sure the test dir (and possibly the test file's dir) is on the LOAD_PATH,
+        # so that 'require "test_helper"' from inside the test works in plain IRB.
+        ensure_load_path_for_test
+
+        # Start coverage
+        Coverage.start(lines: true, branches: true, methods: true)
+
+        # If Rails app, load Rails environment & test_help
+        if @rails_app
+          ENV["RAILS_ENV"]      = "test"
+          ENV["DISABLE_SPRING"] = "1" # ensure we don't use Spring, so coverage is captured
+          require File.expand_path("config/environment", Dir.pwd)
+          require "rails/test_help"
+        else
+          require "bundler/setup"
+        end
+
+        # Now require the test file directly
+        require @test_file
+
+        # Require the source file to make sure it's loaded for coverage
+        require @subject_file
+
+        # Initialize our test stats collector - must happen before tests run
+        stats_collector = TestStatsCollector.instance
+
+        # Run Minitest tests
+        # Redirect stdout to stderr for test output so that it doesn't pollute
+        # the JSON output of the coverage runner
+        original_stdout = $stdout.dup
+        $stdout.reopen($stderr)
+        test_passed = Minitest.run([])
+        $stdout.reopen(original_stdout) # Restore original stdout
+
+        # Report test stats
+        test_count = stats_collector.tests_count
+        assertion_count = stats_collector.assertions_count
+
+        coverage_data = Coverage.result(stop: false)
+
+        file_data = coverage_data[@subject_file]
+        coverage_result =
+          if file_data.nil?
+            # If file never got loaded, coverage is effectively zero for that file
+            { line: 0.0, branch: 0.0, method: 0.0, tests: test_count, assertions: assertion_count }
+          else
+            result = compute_coverage_stats(file_data)
+            result.merge(tests: test_count, assertions: assertion_count)
+          end
+
+        # If the test run failed (returned false), exit 1
+        unless test_passed
+          Roast::Helpers::Logger.error("\nTest failures detected. Exiting with status 1.")
+          exit(1)
+        end
+
+        puts coverage_result.to_json
+      end
+
+      private
+
+      # Ensures that your test directory (and possibly the directory of the test file)
+      # is added to the load path so `require 'test_helper'` works from IRB context.
+      def ensure_load_path_for_test
+        test_dir = File.join(Dir.pwd, "test")
+        $LOAD_PATH.unshift(test_dir) if File.directory?(test_dir) && !$LOAD_PATH.include?(test_dir)
+
+        # Also add the directory of the specific test file; sometimes test files are in subdirs like `test/models`
+        test_file_dir = File.dirname(@test_file)
+        unless $LOAD_PATH.include?(test_file_dir)
+          $LOAD_PATH.unshift(test_file_dir)
+        end
+      end
+
+      def compute_coverage_stats(file_data)
+        lines_info    = file_data[:lines]    || []
+        branches_info = file_data[:branches] || {}
+        methods_info  = file_data[:methods]  || {}
+        source_code_lines = File.readlines(@subject_file).map(&:chomp)
+
+        # --- Line Coverage ---
+        executable_lines = lines_info.count { |count| !count.nil? }
+        covered_lines    = lines_info.count { |count| count && count > 0 }
+        line_percent = if executable_lines.zero?
+          100.0
+        else
+          (covered_lines.to_f / executable_lines * 100).round(2)
+        end
+
+        # --- Branch Coverage ---
+        total_branches   = 0
+        covered_branches = 0
+        uncovered_branches = []
+
+        # Track line numbers with branches for reporting
+        branches_info.each do |line_number, branch_group|
+          # Convert line_number from symbol/array to integer if needed
+          # Ruby Coverage module can return different formats for line numbers
+          line_num = if line_number.is_a?(Array)
+            line_number[2] # Usually the line number is the 3rd element in the array
+          elsif line_number.is_a?(Symbol)
+            # Try to extract line number from a symbol like :line_10
+            begin
+              line_number.to_s.match(/\d+/)&.[](0).to_i
+            rescue
+              0
+            end
+          else
+            line_number.to_i
+          end
+
+          # Adjust for zero-based line numbering if needed
+          actual_line_num = [line_num, 0].max
+
+          # Get the actual code from that line if available
+          line_code = begin
+            source_code_lines[actual_line_num - 1]&.strip
+          rescue
+            "Unknown code"
+          end
+
+          branch_group.each do |_branch_id, count|
+            total_branches += 1
+            if count && count > 0
+              covered_branches += 1
+            else
+              # Add uncovered branch to the result with line number and code
+              uncovered_branches << "Line #{actual_line_num}: #{line_code}"
+            end
+          end
+        end
+
+        branch_percent = if total_branches.zero?
+          100.0
+        else
+          (covered_branches.to_f / total_branches * 100).round(2)
+        end
+
+        # --- Method Coverage ---
+        total_methods   = methods_info.size
+        covered_methods = 0
+        uncovered_methods = []
+
+        methods_info.each do |method_id, count|
+          # Method IDs in Coverage are usually in the format: [class_name, method_name, start_line, end_line]
+          if method_id.is_a?(Array) && method_id.size >= 4
+            class_name, method_name, start_line, end_line = method_id
+            # Construct a user-friendly representation of the method
+            method_signature = "#{class_name}##{method_name} (lines #{start_line}-#{end_line})"
+
+            if count && count > 0
+              covered_methods += 1
+            else
+              # Add uncovered method to the result
+              uncovered_methods << method_signature
+            end
+          elsif count && count > 0
+            # Handle any other format the Coverage module might return
+            covered_methods += 1
+          else
+            uncovered_methods << method_id.to_s
+          end
+        end
+
+        method_percent = if total_methods.zero?
+          100.0
+        else
+          (covered_methods.to_f / total_methods * 100).round(2)
+        end
+
+        {
+          line: line_percent,
+          branch: branch_percent,
+          method: method_percent,
+          uncovered_branches: uncovered_branches,
+          uncovered_methods: uncovered_methods,
+        }
+      end
+    end
+  end
+end

data/lib/roast/helpers/path_resolver.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Roast
+  module Helpers
+    # Utility class for resolving file paths with directory structure issues
+    class PathResolver
+      class << self
+        # Intelligently resolves a path considering possible directory structure issues
+        def resolve(path)
+          # Store original path for logging if needed
+          original_path = path
+
+          # Early return if the path is nil or empty
+          return path if path.nil? || path.empty?
+
+          # First try standard path expansion
+          expanded_path = File.expand_path(path)
+
+          # Return early if the file exists at the expanded path
+          return expanded_path if File.exist?(expanded_path)
+
+          # Get current directory and possible project root paths
+          current_dir = Dir.pwd
+          possible_roots = [
+            current_dir,
+            File.expand_path(File.join(current_dir, "..")),
+            File.expand_path(File.join(current_dir, "../..")),
+            File.expand_path(File.join(current_dir, "../../..")),
+            File.expand_path(File.join(current_dir, "../../../..")),
+            File.expand_path(File.join(current_dir, "../../../../..")),
+          ]
+
+          # Check for directory name duplications anywhere in the path
+          path_parts = expanded_path.split(File::SEPARATOR).reject(&:empty?)
+
+          # Try removing each duplicate segment individually and check if the resulting path exists
+          path_parts.each_with_index do |part, i|
+            next if i == 0 # Skip the first segment
+
+            # Check if this segment appears earlier in the path
+            next unless path_parts[0...i].include?(part)
+
+            # Create a new path without this segment
+            test_parts = path_parts.dup
+            test_parts.delete_at(i)
+
+            test_path = if original_path.start_with?("/")
+              File.join("/", *test_parts)
+            else
+              File.join(test_parts)
+            end
+
+            # If this path exists, return it
+            return test_path if File.exist?(test_path)
+
+            # Also try removing all future occurrences of this segment name
+            duplicate_indices = []
+            path_parts.each_with_index do |segment, idx|
+              if idx > 0 && segment == part && idx >= i
+                duplicate_indices << idx
+              end
+            end
+
+            next if duplicate_indices.none?
+
+            filtered_parts = path_parts.dup
+            # Remove from end to beginning to keep indices valid
+            duplicate_indices.reverse_each { |idx| filtered_parts.delete_at(idx) }
+
+            test_path = if original_path.start_with?("/")
+              File.join("/", *filtered_parts)
+            else
+              File.join(filtered_parts)
+            end
+
+            return test_path if File.exist?(test_path)
+          end
+
+          # Try detecting all duplicates at once
+          seen_segments = {}
+          duplicate_indices = []
+
+          path_parts.each_with_index do |part, i|
+            if seen_segments[part]
+              duplicate_indices << i
+            else
+              seen_segments[part] = true
+            end
+          end
+
+          if duplicate_indices.any?
+            # Try removing all duplicates
+            unique_parts = path_parts.dup
+            # Remove from end to beginning to keep indices valid
+            duplicate_indices.reverse_each { |i| unique_parts.delete_at(i) }
+
+            test_path = if original_path.start_with?("/")
+              File.join("/", *unique_parts)
+            else
+              File.join(unique_parts)
+            end
+
+            return test_path if File.exist?(test_path)
+          end
+
+          # Try relative path resolution from various possible roots
+          relative_path = path.sub(%r{^\./}, "")
+          possible_roots.each do |root|
+            # Try the path as-is from this root
+            candidate = File.join(root, relative_path)
+            return candidate if File.exist?(candidate)
+
+            # Try with a leading slash removed
+            if relative_path.start_with?("/")
+              candidate = File.join(root, relative_path.sub(%r{^/}, ""))
+              return candidate if File.exist?(candidate)
+            end
+          end
+
+          # Try extracting the path after a potential project root
+          if expanded_path.include?("/src/") || expanded_path.include?("/lib/") || expanded_path.include?("/test/")
+            # Potential project markers
+            markers = ["/src/", "/lib/", "/test/", "/app/", "/config/"]
+            markers.each do |marker|
+              next unless expanded_path.include?(marker)
+
+              # Get the part after the marker
+              parts = expanded_path.split(marker, 2)
+              next unless parts.size == 2
+
+              marker_dir = marker.gsub("/", "")
+              relative_from_marker = parts[1]
+
+              # Try each possible root with this marker
+              possible_roots.each do |root|
+                candidate = File.join(root, marker_dir, relative_from_marker)
+                return candidate if File.exist?(candidate)
+              end
+            end
+          end
+
+          # Default to the original expanded path if all else fails
+          expanded_path
+        end
+      end
+    end
+  end
+end

data/lib/roast/helpers/prompt_loader.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string"
+require "erb"
+
+module Roast
+  module Helpers
+    class PromptLoader
+      class << self
+        # Loads a sidecar prompt file for a given context (workflow or step) and target file
+        #
+        # @param context [Object] The workflow or step instance
+        # @param target_file [String] The path to the target file
+        # @return [String, nil] The processed prompt content, or nil if no prompt is found
+        def load_prompt(context, target_file)
+          new(context, target_file).load
+        end
+      end
+
+      def initialize(context, target_file)
+        @context = context
+        @name = context.name
+        @context_path = context.context_path
+        @target_file = target_file
+      end
+
+      def load
+        prompt_content = read_prompt_file(find_prompt_path)
+        return unless prompt_content
+
+        process_erb_if_needed(prompt_content)
+      end
+
+      private
+
+      attr_reader :context, :name, :context_path, :target_file
+
+      def read_prompt_file(path)
+        if path && File.exist?(path)
+          File.read(path)
+        else
+          $stderr.puts "Prompt file for #{name} not found: #{path}"
+        end
+      end
+
+      def find_prompt_path
+        find_specialized_prompt_path(name, extract_file_extensions)
+      end
+
+      def find_specialized_prompt_path(base_name, extensions)
+        context_dir = File.expand_path(context_path)
+
+        # Try each extension to find a specialized prompt
+        extensions.each do |ext|
+          path = File.join(context_dir, "#{base_name}.#{ext}.md")
+          path = File.join(context_dir, "prompt.#{ext}.md") unless File.exist?(path)
+          return path if File.exist?(path)
+        end
+
+        # Check for combined format patterns (like ts+tsx)
+        glob_pattern = File.join(context_dir, "{#{base_name},prompt}.*+*.md")
+        Dir.glob(glob_pattern).each do |combined_path|
+          basename = File.basename(combined_path, ".md")
+          combined_exts = basename.split(".", 2)[1].split("+")
+
+          # Return the first matching combined format
+          return combined_path if extensions.intersect?(combined_exts)
+        end
+
+        # Fall back to the general prompt
+        general_path = File.join(context_dir, "#{base_name}.md")
+        general_path = File.join(context_dir, "prompt.md") unless File.exist?(general_path)
+        general_path if File.exist?(general_path)
+      end
+
+      def extract_file_extensions
+        file_basename = File.basename(target_file)
+
+        if file_basename.end_with?(".md") && file_basename.count(".") > 1
+          without_md = file_basename[0...-3] # Remove .md
+          without_md.split(".", 2)[1]&.split("+") || []
+        else
+          ext = File.extname(target_file)[1..]
+          ext&.empty? ? [] : [ext]
+        end
+      end
+
+      def process_erb_if_needed(content)
+        if content.include?("<%")
+          ERB.new(content, trim_mode: "-").result(context.instance_eval { binding })
+        else
+          content
+        end
+      end
+    end
+  end
+end

data/lib/roast/helpers.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "roast/helpers/logger"
+require "roast/helpers/path_resolver"
+require "roast/helpers/prompt_loader"
+require "roast/helpers/minitest_coverage_runner"
+require "roast/helpers/function_caching_interceptor"
+
+module Roast
+  module Helpers
+  end
+end

data/lib/roast/tools/cmd.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "English"
+require "roast/helpers/logger"
+
+module Roast
+  module Tools
+    module Cmd
+      extend self
+
+      class << self
+        # Add this method to be included in other classes
+        def included(base)
+          base.class_eval do
+            function(
+              :cmd,
+              'Run a command in the current working directory (e.g. "ls", "rake", "ruby"). ' \
+                "You may use this tool to execute tests and verify if they pass.",
+              command: { type: "string", description: "The command to run in a bash shell." },
+            ) do |params|
+              Roast::Tools::Cmd.call(params[:command])
+            end
+          end
+        end
+      end
+
+      def call(command)
+        Roast::Helpers::Logger.info("🔧 Running command: #{command}\n")
+
+        # Validate the command starts with one of the allowed prefixes
+        allowed_prefixes = ["pwd", "find", "ls", "rake", "ruby", "dev"]
+        command_prefix = command.split(" ").first
+
+        err = "Error: Command not allowed. Only commands starting with #{allowed_prefixes.join(", ")} are permitted."
+        return err unless allowed_prefixes.any? do |prefix|
+          command_prefix == prefix
+        end
+
+        # Execute the command in the current working directory
+        result = ""
+
+        # Use a full shell environment for commands, especially for 'dev'
+        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) do |io|
+            result = io.read
+          end
+        else
+          # For other commands, use the original approach
+          IO.popen(command, chdir: Dir.pwd) do |io|
+            result = io.read
+          end
+        end
+
+        exit_status = $CHILD_STATUS.exitstatus
+
+        # Return the command output along with exit status information
+        output = "Command: #{command}\n"
+        output += "Exit status: #{exit_status}\n"
+        output += "Output:\n#{result}"
+
+        output
+      rescue StandardError => e
+        "Error running command: #{e.message}".tap do |error_message|
+          Roast::Helpers::Logger.error(error_message + "\n")
+          Roast::Helpers::Logger.debug(e.backtrace.join("\n") + "\n") if ENV["DEBUG"]
+        end
+      end
+    end
+  end
+end

data/lib/roast/tools/grep.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "roast/helpers/logger"
+
+module Roast
+  module Tools
+    module Grep
+      extend self
+
+      MAX_RESULT_LINES = 100
+
+      class << self
+        # Add this method to be included in other classes
+        def included(base)
+          base.class_eval do
+            function(
+              :grep,
+              'Search for a string in the project using `grep -rni "#{@search_string}" .` in the project root',
+              string: { type: "string", description: "The string to search for" },
+            ) do |params|
+              Roast::Tools::Grep.call(params[:string]).tap do |result|
+                Roast::Helpers::Logger.debug(result) if ENV["DEBUG"]
+              end
+            end
+          end
+        end
+      end
+
+      def call(string)
+        Roast::Helpers::Logger.info("🔍 Grepping for string: #{string}\n")
+        # Escape regex special characters in strings with curly braces
+        # Example: "import {render}" becomes "import \{render\}"
+        escaped_string = string.gsub(/(\{|\})/, '\\\\\\1')
+        %x(rg -C 4 --trim --color=never --heading -F -- "#{escaped_string}" . | head -n #{MAX_RESULT_LINES})
+      rescue StandardError => e
+        "Error grepping for string: #{e.message}".tap do |error_message|
+          Roast::Helpers::Logger.error(error_message + "\n")
+          Roast::Helpers::Logger.debug(e.backtrace.join("\n") + "\n") if ENV["DEBUG"]
+        end
+      end
+    end
+  end
+end

data/lib/roast/tools/read_file.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "roast/helpers/logger"
+
+module Roast
+  module Tools
+    module ReadFile
+      extend self
+
+      class << self
+        def included(base)
+          base.class_eval do
+            function(
+              :read_file,
+              "Read the contents of a file. (If the path is a directory, list the contents.) " \
+                "NOTE: Do not use for .rbi files, they are not useful.",
+              path: { type: "string", description: "The path to the file to read" },
+            ) do |params|
+              Roast::Tools::ReadFile.call(params[:path]).tap do |result|
+                if ENV["DEBUG"]
+                  result_lines = result.lines
+                  if result_lines.size > 20
+                    Roast::Helpers::Logger.debug(result_lines.first(20).join + "\n...")
+                  else
+                    Roast::Helpers::Logger.debug(result)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def call(path)
+        Roast::Helpers::Logger.info("📖 Reading file: #{path}\n")
+        if File.directory?(path)
+          %x(ls -la #{path})
+        else
+          File.read(File.join(Dir.pwd, path))
+        end
+      rescue StandardError => e
+        "Error reading file: #{e.message}".tap do |error_message|
+          Roast::Helpers::Logger.error(error_message + "\n")
+          Roast::Helpers::Logger.debug(e.backtrace.join("\n") + "\n") if ENV["DEBUG"]
+        end
+      end
+    end
+  end
+end