roast-ai 0.4.0 → 0.4.2

data/lib/roast/workflow/step_executor_coordinator.rb

@@ -28,11 +28,11 @@ module Roast
           is_last_step = (index == workflow_steps.length - 1)
           case step
           when Hash
-            execute(step, is_last_step: is_last_step)
+            execute(step, is_last_step:)
           when Array
-            execute(step, is_last_step: is_last_step)
+            execute(step, is_last_step:)
           when String
-            execute(step, is_last_step: is_last_step)
+            execute(step, is_last_step:)
             # Handle pause after string steps
             if @context.workflow.pause_step_name == step
               Kernel.binding.irb # rubocop:disable Lint/Debugger
@@ -62,17 +62,17 @@ module Roast
         when StepTypeResolver::AGENT_STEP
           execute_agent_step(step, options)
         when StepTypeResolver::GLOB_STEP
-          execute_glob_step(step)
+          execute_glob_step(step, options)
         when StepTypeResolver::ITERATION_STEP
-          execute_iteration_step(step)
+          execute_iteration_step(step, options)
         when StepTypeResolver::CONDITIONAL_STEP
-          execute_conditional_step(step)
+          execute_conditional_step(step, options)
         when StepTypeResolver::CASE_STEP
-          execute_case_step(step)
+          execute_case_step(step, options)
         when StepTypeResolver::INPUT_STEP
-          execute_input_step(step)
+          execute_input_step(step, options)
         when StepTypeResolver::HASH_STEP
-          execute_hash_step(step)
+          execute_hash_step(step, options)
         when StepTypeResolver::PARALLEL_STEP
           # Use factory for parallel steps
           executor = StepExecutorFactory.for(step, workflow_executor)
@@ -189,11 +189,11 @@ module Roast
         step_orchestrator.execute_step(step_name, exit_on_error:, step_key: options[:step_key], agent_type: :coding_agent)
       end
 
-      def execute_glob_step(step)
+      def execute_glob_step(step, options = {})
         Dir.glob(step).join("\n")
       end
 
-      def execute_iteration_step(step)
+      def execute_iteration_step(step, options = {})
         name = step.keys.first
         command = step[name]
 
@@ -206,19 +206,19 @@ module Roast
         end
       end
 
-      def execute_conditional_step(step)
+      def execute_conditional_step(step, options = {})
         conditional_executor.execute_conditional(step)
       end
 
-      def execute_case_step(step)
+      def execute_case_step(step, options = {})
         case_executor.execute_case(step)
       end
 
-      def execute_input_step(step)
+      def execute_input_step(step, options = {})
         input_executor.execute_input(step["input"])
       end
 
-      def execute_hash_step(step)
+      def execute_hash_step(step, options = {})
         name, command = step.to_a.flatten
         interpolated_name = interpolator.interpolate(name)
 
@@ -230,7 +230,8 @@ module Roast
 
           # Execute the command directly using the appropriate executor
           # Pass the original key name for configuration lookup
-          result = execute(interpolated_command, { exit_on_error: exit_on_error, step_key: interpolated_name })
+          # Merge options to preserve is_last_step
+          result = execute(interpolated_command, { exit_on_error:, step_key: interpolated_name }.merge(options))
           context.workflow.output[interpolated_name] = result
           result
         end
@@ -247,10 +248,10 @@ module Roast
         if StepTypeResolver.command_step?(interpolated_step)
           # Command step - execute directly, preserving any passed options
           exit_on_error = options.fetch(:exit_on_error, true)
-          execute_command_step(interpolated_step, { exit_on_error: exit_on_error })
+          execute_command_step(interpolated_step, { exit_on_error: })
         else
           exit_on_error = options.fetch(:exit_on_error, context.exit_on_error?(step))
-          execute_standard_step(interpolated_step, options.merge(exit_on_error: exit_on_error))
+          execute_standard_step(interpolated_step, options.merge(exit_on_error:))
         end
       end
 

data/lib/roast/workflow/step_executor_with_reporting.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Decorator that adds token consumption reporting to step execution
+    class StepExecutorWithReporting
+      def initialize(base_executor, context, output: $stderr)
+        @base_executor = base_executor
+        @context = context
+        @reporter = StepCompletionReporter.new(output: output)
+        @name_extractor = StepNameExtractor.new
+      end
+
+      def execute(step, options = {})
+        # Track tokens before execution
+        tokens_before = @context.workflow.context_manager&.total_tokens || 0
+
+        # Execute the step
+        result = @base_executor.execute(step, options)
+
+        # Report token consumption after successful execution
+        tokens_after = @context.workflow.context_manager&.total_tokens || 0
+        tokens_consumed = tokens_after - tokens_before
+
+        step_type = StepTypeResolver.resolve(step, @context)
+        step_name = @name_extractor.extract(step, step_type)
+        @reporter.report(step_name, tokens_consumed, tokens_after)
+
+        result
+      end
+
+      # Override execute_steps to ensure reporting happens for each step
+      def execute_steps(workflow_steps)
+        workflow_steps.each_with_index do |step, index|
+          is_last_step = (index == workflow_steps.length - 1)
+          case step
+          when Hash
+            execute(step, is_last_step:)
+          when Array
+            execute(step, is_last_step:)
+          when String
+            execute(step, is_last_step:)
+            # Handle pause after string steps
+            if @context.workflow.pause_step_name == step
+              Kernel.binding.irb # rubocop:disable Lint/Debugger
+            end
+          else
+            # For other types, delegate to base executor
+            execute(step, is_last_step:)
+          end
+        end
+      end
+
+      # Delegate all other methods to the base executor
+      def method_missing(method, *args, **kwargs, &block)
+        if @base_executor.respond_to?(method)
+          @base_executor.send(method, *args, **kwargs, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        @base_executor.respond_to?(method, include_private) || super
+      end
+    end
+  end
+end

data/lib/roast/workflow/step_loader.rb

@@ -4,7 +4,7 @@ module Roast
   module Workflow
     # Handles loading and instantiation of workflow steps
     class StepLoader
-      DEFAULT_MODEL = "openai/gpt-4o-mini"
+      DEFAULT_MODEL = "gpt-4o-mini"
 
       # Custom exception classes
       class StepLoaderError < StandardError

data/lib/roast/workflow/step_name_extractor.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Extracts human-readable names from various step types
+    class StepNameExtractor
+      def extract(step, step_type)
+        case step_type
+        when StepTypeResolver::COMMAND_STEP
+          extract_command_name(step)
+        when StepTypeResolver::HASH_STEP
+          extract_hash_step_name(step)
+        when StepTypeResolver::ITERATION_STEP
+          extract_iteration_step_name(step)
+        when StepTypeResolver::CONDITIONAL_STEP
+          extract_conditional_step_name(step)
+        when StepTypeResolver::CASE_STEP
+          "case"
+        when StepTypeResolver::INPUT_STEP
+          "input"
+        when StepTypeResolver::AGENT_STEP
+          StepTypeResolver.extract_name(step)
+        when StepTypeResolver::STRING_STEP
+          step.to_s
+        else
+          step.to_s
+        end
+      end
+
+      private
+
+      def extract_command_name(step)
+        cmd = step.to_s.strip
+        cmd.length > 20 ? "#{cmd[0..19]}..." : cmd
+      end
+
+      def extract_hash_step_name(step)
+        key, value = step.to_a.first
+
+        # Check if this looks like an inline prompt (key is similar to sanitized value)
+        if value.is_a?(String)
+          # Get first non-empty line
+          first_line = value.lines.map(&:strip).find { |line| !line.empty? } || ""
+
+          # If key looks like it was auto-generated from the content, use truncated content
+          sanitized = first_line.downcase.gsub(/[^a-z0-9_]/, "_").squeeze("_").gsub(/^_|_$/, "")
+          if key.to_s == sanitized || key.to_s.start_with?(sanitized[0..15])
+            # This is likely an inline prompt
+            first_line.length > 20 ? "#{first_line[0..19]}..." : first_line
+          else
+            # This is a labeled step
+            key.to_s
+          end
+        else
+          key.to_s
+        end
+      end
+
+      def extract_iteration_step_name(step)
+        if step.key?("each")
+          items = step["each"]
+          count = items.respond_to?(:size) ? items.size : "?"
+          "each (#{count} items)"
+        elsif step.key?("repeat")
+          config = step["repeat"]
+          times = config.is_a?(Hash) ? config["times"] || "?" : config
+          "repeat (#{times} times)"
+        else
+          "iteration"
+        end
+      end
+
+      def extract_conditional_step_name(step)
+        if step.key?("if")
+          "if"
+        elsif step.key?("unless")
+          "unless"
+        else
+          "conditional"
+        end
+      end
+    end
+  end
+end

data/lib/roast/workflow/validation_command.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Handles the validation command logic for the CLI
+    class ValidationCommand
+      def initialize(options = {})
+        @options = options
+      end
+
+      def execute(workflow_path = nil)
+        workflow_files = resolve_workflow_files(workflow_path)
+        validate_workflows(workflow_files)
+      end
+
+      private
+
+      def resolve_workflow_files(workflow_path)
+        if workflow_path.nil?
+          find_all_workflows
+        else
+          [expand_workflow_path(workflow_path)]
+        end
+      end
+
+      def find_all_workflows
+        roast_dir = File.join(Dir.pwd, "roast")
+        unless File.directory?(roast_dir)
+          raise Thor::Error, "No roast/ directory found in current path"
+        end
+
+        workflow_files = Dir.glob(File.join(roast_dir, "**/workflow.yml")).sort
+        if workflow_files.empty?
+          raise Thor::Error, "No workflow.yml files found in roast/ directory"
+        end
+
+        workflow_files
+      end
+
+      def expand_workflow_path(workflow_path)
+        expanded_path = if workflow_path.end_with?(".yml", ".yaml") || workflow_path.include?("/")
+          File.expand_path(workflow_path)
+        else
+          File.expand_path("roast/#{workflow_path}/workflow.yml")
+        end
+
+        unless File.exist?(expanded_path)
+          raise Thor::Error, "Workflow file not found: #{expanded_path}"
+        end
+
+        expanded_path
+      end
+
+      def validate_workflows(workflow_files)
+        results = ValidationResults.new
+
+        validate_multiple_workflows_display(workflow_files, results)
+
+        display_summary(results)
+        exit_if_needed(results)
+      end
+
+      def validate_multiple_workflows_display(workflow_files, results)
+        ::CLI::UI::Frame.open("Validating #{workflow_files.size} workflow(s)") do
+          validate_each_workflow(workflow_files, results)
+        end
+      end
+
+      def validate_each_workflow(workflow_files, results)
+        workflow_files.each do |workflow_path|
+          workflow_name = extract_workflow_name(workflow_path)
+          validator = create_validator(workflow_path)
+          # Ensure validation is performed to populate errors/warnings
+          is_valid = validator.valid?
+          results.add_result(workflow_path, validator)
+
+          display_workflow_result(workflow_name, validator, is_valid)
+        end
+      end
+
+      def display_workflow_result(workflow_name, validator, is_valid)
+        if is_valid
+          if validator.warnings.empty?
+            puts ::CLI::UI.fmt("{{green:✓}} {{bold:#{workflow_name}}}")
+          else
+            puts ::CLI::UI.fmt("{{green:✓}} {{bold:#{workflow_name}}} ({{yellow:#{validator.warnings.size} warning(s)}})")
+          end
+        else
+          puts ::CLI::UI.fmt("{{red:✗}} {{bold:#{workflow_name}}} ({{red:#{validator.errors.size} error(s)}})")
+        end
+      end
+
+      def create_validator(workflow_path)
+        yaml_content = File.read(workflow_path)
+        Validators::ValidationOrchestrator.new(yaml_content, workflow_path)
+      end
+
+      def extract_workflow_name(workflow_path)
+        workflow_path.sub("#{Dir.pwd}/roast/", "").sub("/workflow.yml", "")
+      end
+
+      def display_summary(results)
+        puts
+
+        if results.total_errors == 0 && results.total_warnings == 0
+          puts ::CLI::UI.fmt("{{green:All workflows are valid!}}")
+        elsif results.total_errors == 0
+          puts ::CLI::UI.fmt("{{green:All workflows are valid}} with {{yellow:#{results.total_warnings} total warning(s)}}")
+          display_all_warnings(results)
+        else
+          puts ::CLI::UI.fmt("{{red:Validation failed:}} #{results.total_errors} error(s), #{results.total_warnings} warning(s)")
+          display_all_errors(results)
+          display_all_warnings(results) if results.total_warnings > 0
+        end
+      end
+
+      def exit_if_needed(results)
+        if results.total_errors > 0
+          exit(1)
+        elsif results.total_warnings > 0 && @options[:strict]
+          exit(1)
+        end
+      end
+
+      def display_errors(errors)
+        ::CLI::UI::Frame.open("Errors", color: :red) do
+          errors.each do |error|
+            puts ::CLI::UI.fmt("{{red:• #{error[:message]}}}")
+            puts ::CLI::UI.fmt("  {{gray:→ #{error[:suggestion]}}}") if error[:suggestion]
+            puts
+          end
+        end
+      end
+
+      def display_warnings(warnings)
+        ::CLI::UI::Frame.open("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
+
+      def display_all_errors(results)
+        results.results_with_errors.each do |result|
+          workflow_name = extract_workflow_name(result[:path])
+          ::CLI::UI::Frame.open("Errors in #{workflow_name}", color: :red) do
+            result[:validator].errors.each do |error|
+              puts ::CLI::UI.fmt("{{red:• #{error[:message]}}}")
+              puts ::CLI::UI.fmt("  {{gray:→ #{error[:suggestion]}}}") if error[:suggestion]
+              puts
+            end
+          end
+        end
+      end
+
+      def display_all_warnings(results)
+        results.results_with_warnings.each do |result|
+          workflow_name = extract_workflow_name(result[:path])
+          ::CLI::UI::Frame.open("Warnings in #{workflow_name}", color: :yellow) do
+            result[:validator].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
+
+      # Tracks validation results across multiple workflows
+      class ValidationResults
+        attr_reader :total_errors, :total_warnings
+
+        def initialize
+          @total_errors = 0
+          @total_warnings = 0
+          @results = []
+        end
+
+        def add_result(workflow_path, validator)
+          @results << { path: workflow_path, validator: validator }
+          @total_errors += validator.errors.size
+          @total_warnings += validator.warnings.size
+        end
+
+        def results_with_errors
+          @results.select { |result| result[:validator].errors.any? }
+        end
+
+        def results_with_warnings
+          @results.select { |result| result[:validator].warnings.any? }
+        end
+      end
+    end
+  end
+end

data/lib/roast/workflow/validators/base_validator.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    module Validators
+      # Base class for all validators
+      class BaseValidator
+        attr_reader :errors, :warnings
+
+        def initialize(parsed_yaml, workflow_path = nil)
+          @parsed_yaml = parsed_yaml
+          @workflow_path = workflow_path
+          @errors = []
+          @warnings = []
+        end
+
+        def validate
+          raise NotImplementedError, "Subclasses must implement validate"
+        end
+
+        def valid?
+          validate
+          @errors.empty?
+        end
+
+        protected
+
+        def add_error(type:, message:, suggestion: nil, **metadata)
+          error = { type: type, message: message }
+          error[:suggestion] = suggestion if suggestion
+          error.merge!(metadata)
+          @errors << error
+        end
+
+        def add_warning(type:, message:, suggestion: nil, **metadata)
+          warning = { type: type, message: message }
+          warning[:suggestion] = suggestion if suggestion
+          warning.merge!(metadata)
+          @warnings << warning
+        end
+      end
+    end
+  end
+end