roast-ai 0.4.0 → 0.4.2

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

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    module Validators
+      # Validates dependencies: tools, step references, and resources
+      class DependencyValidator < BaseValidator
+        def initialize(parsed_yaml, workflow_path = nil, step_collector: nil)
+          super(parsed_yaml, workflow_path)
+          @step_collector = step_collector || StepCollector.new(parsed_yaml)
+        end
+
+        def validate
+          validate_tool_dependencies
+          validate_step_references
+          validate_resource_dependencies
+        end
+
+        private
+
+        def validate_tool_dependencies
+          return unless @parsed_yaml["tools"]
+
+          tools = extract_all_tools(@parsed_yaml["tools"])
+
+          tools.each do |tool|
+            next if tool_available?(tool)
+
+            add_error(
+              type: :tool_dependency,
+              tool: tool,
+              message: "Tool '#{tool}' is not available",
+              suggestion: suggest_tool_fix(tool),
+            )
+          end
+        end
+
+        def validate_step_references
+          all_steps = @step_collector.all_steps
+          step_names = all_steps.map { |s| extract_step_name(s) }.compact.uniq
+
+          check_step_references_in_config(@parsed_yaml, step_names)
+        end
+
+        def validate_resource_dependencies
+          # Validate file resources if target is specified
+          if @parsed_yaml["target"] && @workflow_path
+            validate_target_resource(@parsed_yaml["target"])
+          end
+
+          # Validate prompt files exist
+          validate_prompt_files if @workflow_path
+        end
+
+        def tool_available?(tool_name)
+          # Check if it's an MCP tool first
+          tools_config = @parsed_yaml["tools"] || []
+          tools_config.each do |tool_entry|
+            if tool_entry.is_a?(Hash) && tool_entry.keys.include?(tool_name)
+              # It's an MCP tool configuration
+              return true
+            end
+          end
+
+          # Check if tool module exists
+          begin
+            tool_name.constantize
+            true
+          rescue NameError
+            false
+          end
+        end
+
+        def suggest_tool_fix(tool)
+          # Suggest similar tools or common fixes
+          available_tools = [
+            "Roast::Tools::Bash",
+            "Roast::Tools::Cmd",
+            "Roast::Tools::ReadFile",
+            "Roast::Tools::WriteFile",
+            "Roast::Tools::UpdateFiles",
+            "Roast::Tools::SearchFile",
+            "Roast::Tools::Grep",
+            "Roast::Tools::AskUser",
+            "Roast::Tools::CodingAgent",
+          ]
+
+          # Simple similarity check
+          tool_base = tool.split("::").last&.downcase || tool.downcase
+          suggestions = available_tools.select do |t|
+            t_base = t.split("::").last&.downcase || ""
+            t_base.include?(tool_base) || tool_base.include?(t_base)
+          end
+
+          if suggestions.any?
+            "Did you mean: #{suggestions.join(", ")}?"
+          else
+            "Ensure the tool module exists or check the tool name spelling"
+          end
+        end
+
+        def extract_all_tools(tools_config)
+          tools = []
+          tools_config.each do |tool_entry|
+            case tool_entry
+            when String
+              tools << tool_entry
+            when Hash
+              tool_entry.each_key do |tool_name|
+                tools << tool_name
+              end
+            end
+          end
+          tools
+        end
+
+        def extract_step_name(step)
+          case step
+          when String
+            step
+          when Hash
+            # Complex step types don't have simple names
+            nil
+          end
+        end
+
+        def check_step_references_in_config(config, valid_step_names)
+          # Check steps array
+          ["steps", "pre_processing", "post_processing"].each do |key|
+            if config[key].is_a?(Array)
+              check_step_references(config[key], valid_step_names)
+            end
+          end
+        end
+
+        def check_step_references(steps, valid_step_names, path = [])
+          steps.each_with_index do |step, index|
+            current_path = path + [index]
+
+            case step
+            when Hash
+              # Check conditions that might reference steps
+              ["if", "unless", "case"].each do |condition_key|
+                next unless step[condition_key]
+
+                condition = step[condition_key]
+                next unless condition.is_a?(String) && !condition.include?("{{") && !condition.include?("$(")
+
+                # Check if it looks like a step reference (snake_case identifier)
+                # and is not a known boolean value
+                next unless condition.match?(/^[a-z_]+$/) && !["true", "false", "yes", "no", "on", "off"].include?(condition)
+
+                # This looks like it could be a step reference
+                next if valid_step_names.include?(condition)
+
+                add_error(
+                  type: :step_reference,
+                  message: "Step '#{condition}' referenced in #{condition_key} condition does not exist",
+                  suggestion: "Ensure step '#{condition}' is defined before it's referenced",
+                )
+              end
+
+              # Check nested steps
+              ["then", "else", "steps"].each do |key|
+                if step[key].is_a?(Array)
+                  check_step_references(step[key], valid_step_names, current_path + [key])
+                end
+              end
+
+              # Check case/when branches
+              if step["when"].is_a?(Hash)
+                step["when"].each do |when_value, when_steps|
+                  if when_steps.is_a?(Array)
+                    check_step_references(when_steps, valid_step_names, current_path + ["when", when_value])
+                  end
+                end
+              end
+            when Array
+              check_step_references(step, valid_step_names, current_path)
+            end
+          end
+        end
+
+        def validate_target_resource(target)
+          return unless @workflow_path
+
+          workflow_dir = File.dirname(@workflow_path)
+
+          # If target is a glob pattern or shell command, skip file validation
+          return if target.include?("*") || target.start_with?("$(")
+
+          target_path = File.expand_path(target, workflow_dir)
+          unless File.exist?(target_path)
+            add_warning(
+              type: :resource,
+              message: "Target file '#{target}' does not exist",
+              suggestion: "Ensure the target file exists or use a glob pattern",
+            )
+          end
+        end
+
+        def validate_prompt_files
+          workflow_dir = File.dirname(@workflow_path)
+          all_steps = @step_collector.all_steps
+
+          all_steps.each do |step|
+            next unless step.is_a?(String)
+
+            # Check if corresponding prompt file exists
+            prompt_path = File.join(workflow_dir, step, "prompt.md")
+            next if File.exist?(prompt_path)
+
+            add_warning(
+              type: :resource,
+              message: "Prompt file missing for step '#{step}'",
+              suggestion: "Create file: #{prompt_path}",
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    module Validators
+      # Validates workflow configuration for best practices and common issues
+      class LintingValidator < BaseValidator
+        # Configurable thresholds
+        MAX_STEPS = 20
+        MAX_NESTING_DEPTH = 5
+
+        def initialize(parsed_yaml, workflow_path = nil, step_collector: nil)
+          super(parsed_yaml, workflow_path)
+          @step_collector = step_collector || StepCollector.new(parsed_yaml)
+        end
+
+        def validate
+          lint_naming_conventions
+          lint_step_complexity
+          lint_common_mistakes
+        end
+
+        private
+
+        def lint_naming_conventions
+          # Check workflow name
+          if @parsed_yaml["name"].nil? || @parsed_yaml["name"].empty?
+            add_warning(
+              type: :naming,
+              message: "Workflow should have a descriptive name",
+              suggestion: "Add a 'name' field to your workflow configuration",
+            )
+          end
+
+          # Check step naming
+          all_steps = @step_collector.all_steps
+          all_steps.each do |step|
+            next unless step.is_a?(String) && !step.match?(/^[a-z_]+$/)
+
+            add_warning(
+              type: :naming,
+              step: step,
+              message: "Step name '#{step}' should use snake_case",
+              suggestion: "Rename to '#{step.downcase.gsub(/[^a-z0-9]/, "_")}'",
+            )
+          end
+        end
+
+        def lint_step_complexity
+          # Check for overly complex workflows
+          all_steps = @step_collector.all_steps
+          if all_steps.size > MAX_STEPS
+            add_warning(
+              type: :complexity,
+              message: "Workflow has #{all_steps.size} steps, consider breaking it into smaller workflows",
+              suggestion: "Use sub-workflows or modularize complex logic",
+            )
+          end
+
+          # Check for deeply nested conditions
+          check_nesting_depth(@parsed_yaml["steps"] || [])
+        end
+
+        def lint_common_mistakes
+          # Missing error handling
+          if !@parsed_yaml["exit_on_error"] && !error_handling?
+            add_warning(
+              type: :error_handling,
+              message: "No error handling configured",
+              suggestion: "Consider adding 'exit_on_error: true' or error handling steps",
+            )
+          end
+        end
+
+        def check_nesting_depth(steps, depth = 0)
+          steps.each do |step|
+            next unless step.is_a?(Hash)
+
+            current_depth = depth + 1
+
+            if current_depth > MAX_NESTING_DEPTH
+              add_warning(
+                type: :complexity,
+                message: "Excessive nesting depth (#{current_depth} levels)",
+                suggestion: "Consider extracting nested logic into separate steps or workflows",
+              )
+            end
+
+            # Check nested steps
+            ["steps", "then", "else", "true", "false"].each do |key|
+              check_nesting_depth(step[key], current_depth) if step[key].is_a?(Array)
+            end
+
+            # Check case/when branches
+            next unless step["when"]
+
+            step["when"].each_value do |when_steps|
+              check_nesting_depth(when_steps, current_depth) if when_steps.is_a?(Array)
+            end
+          end
+        end
+
+        def error_handling?
+          # Check if workflow has any error handling mechanisms
+          all_steps = @step_collector.all_steps
+          all_steps.any? do |step|
+            step.is_a?(Hash) && (step["rescue"] || step["ensure"])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    module Validators
+      # Validates workflow configuration against JSON schema
+      class SchemaValidator < BaseValidator
+        attr_reader :parsed_yaml
+
+        def initialize(yaml_content, workflow_path = nil) # rubocop:disable Lint/MissingSuper
+          @yaml_content = yaml_content&.strip || ""
+          @workflow_path = workflow_path
+          @errors = []
+          @warnings = []
+
+          begin
+            @parsed_yaml = @yaml_content.empty? ? {} : YAML.safe_load(@yaml_content)
+          rescue Psych::SyntaxError => e
+            @errors << format_yaml_error(e)
+            @parsed_yaml = {}
+          end
+        end
+
+        def validate
+          if @parsed_yaml.empty?
+            @errors << {
+              type: :empty_configuration,
+              message: "Workflow configuration is empty",
+              suggestion: "Provide a valid workflow configuration with required fields: name, tools, and steps",
+            }
+            return
+          end
+
+          validator = Validator.new(@yaml_content)
+          unless validator.valid?
+            validator.errors.each do |error|
+              @errors << format_schema_error(error)
+            end
+          end
+        end
+
+        private
+
+        def format_yaml_error(error)
+          {
+            type: :yaml_syntax,
+            message: "YAML syntax error: #{error.message}",
+            line: error.line,
+            column: error.column,
+            suggestion: "Check YAML syntax at line #{error.line}, column #{error.column}",
+          }
+        end
+
+        def format_schema_error(error)
+          # Parse JSON Schema error and make it more user-friendly
+          if error.include?("did not contain a required property")
+            # Extract property name from error
+            match = error.match(/required property of '([^']+)'/)
+            if match
+              property = match[1]
+              {
+                type: :schema,
+                message: "Missing required field: '#{property}'",
+                suggestion: "Add '#{property}' to your workflow configuration",
+              }
+            else
+              {
+                type: :schema,
+                message: error,
+                suggestion: "Check the required fields in your workflow configuration",
+              }
+            end
+          elsif error.include?("does not match")
+            {
+              type: :schema,
+              message: error,
+              suggestion: "Check the workflow schema documentation for valid values",
+            }
+          else
+            {
+              type: :schema,
+              message: error,
+              suggestion: "Refer to the workflow schema for correct configuration structure",
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    module Validators
+      # Collects and caches all steps from a workflow configuration
+      class StepCollector
+        def initialize(parsed_yaml)
+          @parsed_yaml = parsed_yaml
+          @all_steps = nil
+        end
+
+        def all_steps
+          @all_steps ||= collect_all_steps(@parsed_yaml)
+        end
+
+        private
+
+        def collect_all_steps(config, steps = [])
+          # Recursively collect all steps from the configuration
+          ["steps", "pre_processing", "post_processing"].each do |key|
+            if config[key]
+              steps.concat(extract_steps_from_array(config[key]))
+            end
+          end
+          steps
+        end
+
+        def extract_steps_from_array(steps_array, collected = [])
+          steps_array.each do |step|
+            case step
+            when String
+              collected << step
+            when Hash
+              if step["steps"]
+                collected.concat(extract_steps_from_array(step["steps"]))
+              end
+              # Handle conditional steps
+              ["then", "else", "true", "false"].each do |branch|
+                if step[branch]
+                  collected.concat(extract_steps_from_array(step[branch]))
+                end
+              end
+              # Handle case/when steps
+              step["when"]&.each_value do |when_steps|
+                collected.concat(extract_steps_from_array(when_steps))
+              end
+            when Array
+              collected.concat(extract_steps_from_array(step))
+            end
+          end
+          collected
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    module Validators
+      # Orchestrates all validators and aggregates results
+      class ValidationOrchestrator
+        attr_reader :errors, :warnings
+
+        def initialize(yaml_content, workflow_path = nil)
+          @yaml_content = yaml_content
+          @workflow_path = workflow_path
+          @errors = []
+          @warnings = []
+        end
+
+        def valid?
+          # First run schema validation
+          schema_validator = SchemaValidator.new(@yaml_content, @workflow_path)
+
+          unless schema_validator.valid?
+            @errors = schema_validator.errors
+            @warnings = schema_validator.warnings
+            return false
+          end
+
+          parsed_yaml = schema_validator.parsed_yaml
+
+          # If schema is valid, run other validators
+          if @errors.empty?
+            step_collector = StepCollector.new(parsed_yaml)
+
+            # Run dependency validation
+            dependency_validator = DependencyValidator.new(parsed_yaml, @workflow_path, step_collector: step_collector)
+            dependency_validator.validate
+            @errors.concat(dependency_validator.errors)
+            @warnings.concat(dependency_validator.warnings)
+
+            # Run linting only if no errors
+            if @errors.empty?
+              linting_validator = LintingValidator.new(parsed_yaml, @workflow_path, step_collector: step_collector)
+              linting_validator.validate
+              @warnings.concat(linting_validator.warnings)
+            end
+          end
+
+          @errors.empty?
+        end
+      end
+    end
+  end
+end

data/lib/roast/workflow/workflow_executor.rb

@@ -66,13 +66,13 @@ module Roast
         @step_loader = step_loader || StepLoader.new(workflow, config_hash, context_path, phase: phase)
         @command_executor = command_executor || CommandExecutor.new(logger: @error_handler)
         @interpolator = interpolator || Interpolator.new(workflow, logger: @error_handler)
-        @state_manager = state_manager || StateManager.new(workflow, logger: @error_handler)
+        @state_manager = state_manager || StateManager.new(workflow, logger: @error_handler, storage_type: workflow.storage_type)
         @iteration_executor = iteration_executor || IterationExecutor.new(workflow, context_path, @state_manager, config_hash)
         @conditional_executor = conditional_executor || ConditionalExecutor.new(workflow, context_path, @state_manager, self)
         @step_orchestrator = step_orchestrator || StepOrchestrator.new(workflow, @step_loader, @state_manager, @error_handler, self)
 
         # Initialize coordinator with dependencies
-        @step_executor_coordinator = step_executor_coordinator || StepExecutorCoordinator.new(
+        base_coordinator = step_executor_coordinator || StepExecutorCoordinator.new(
           context: @context,
           dependencies: {
             workflow_executor: self,
@@ -84,6 +84,13 @@ module Roast
             error_handler: @error_handler,
           },
         )
+
+        # Only wrap with reporting decorator if workflow has token tracking enabled
+        @step_executor_coordinator = if workflow.respond_to?(:context_manager) && workflow.context_manager
+          StepExecutorWithReporting.new(base_coordinator, @context)
+        else
+          base_coordinator
+        end
       end
 
       # Logger interface methods for backward compatibility
@@ -111,8 +118,8 @@ module Roast
         @interpolator.interpolate(text)
       end
 
-      def execute_step(name, exit_on_error: true)
-        @step_executor_coordinator.execute(name, exit_on_error: exit_on_error)
+      def execute_step(name, exit_on_error: true, is_last_step: nil)
+        @step_executor_coordinator.execute(name, exit_on_error:, is_last_step:)
       rescue StepLoader::StepNotFoundError => e
         raise StepNotFoundError.new(e.message, step_name: e.step_name, original_error: e.original_error)
       rescue StepLoader::StepExecutionError => e

data/lib/roast/workflow/workflow_initializer.rb

@@ -10,6 +10,7 @@ module Roast
 
       def setup
         load_roast_initializers
+        check_raix_configuration
         include_tools
         configure_api_client
       end
@@ -20,6 +21,85 @@ module Roast
         Roast::Initializers.load_all
       end
 
+      def check_raix_configuration
+        # Skip check in test environment
+        return if ENV["RAILS_ENV"] == "test" || ENV["RACK_ENV"] == "test" || defined?(Minitest)
+
+        # Only check if the workflow has steps that would need API access
+        return if @configuration.steps.empty?
+
+        # Check if Raix has been configured with the appropriate client
+        case @configuration.api_provider
+        when :openai
+          if Raix.configuration.openai_client.nil?
+            warn_about_missing_raix_configuration(:openai)
+          end
+        when :openrouter
+          if Raix.configuration.openrouter_client.nil?
+            warn_about_missing_raix_configuration(:openrouter)
+          end
+        when nil
+          # If no api_provider is set but we have steps that might need API access,
+          # check if any client is configured
+          if Raix.configuration.openai_client.nil? && Raix.configuration.openrouter_client.nil?
+            warn_about_missing_raix_configuration(:any)
+          end
+        end
+      end
+
+      def warn_about_missing_raix_configuration(provider)
+        ::CLI::UI.frame_style = :box
+        ::CLI::UI::Frame.open("{{red:Raix Configuration Missing}}", color: :red) do
+          case provider
+          when :openai
+            puts ::CLI::UI.fmt("{{yellow:⚠️  Warning: Raix OpenAI client is not configured!}}")
+          when :openrouter
+            puts ::CLI::UI.fmt("{{yellow:⚠️  Warning: Raix OpenRouter client is not configured!}}")
+          else
+            puts ::CLI::UI.fmt("{{yellow:⚠️  Warning: Raix is not configured!}}")
+          end
+          puts
+          puts "Roast requires Raix to be properly initialized to make API calls."
+          puts ::CLI::UI.fmt("To fix this, create a file at {{cyan:.roast/initializers/raix.rb}} with:")
+          puts
+          puts ::CLI::UI.fmt("{{cyan:# frozen_string_literal: true}}")
+          puts
+          puts ::CLI::UI.fmt("{{cyan:require \"raix\"}}")
+
+          if provider == :openrouter
+            puts ::CLI::UI.fmt("{{cyan:require \"open_router\"}}")
+            puts
+            puts ::CLI::UI.fmt("{{cyan:Raix.configure do |config|}}")
+            puts ::CLI::UI.fmt("{{cyan:  config.openrouter_client = OpenRouter::Client.new(}}")
+            puts ::CLI::UI.fmt("{{cyan:    access_token: ENV.fetch(\"OPENROUTER_API_KEY\"),}}")
+            puts ::CLI::UI.fmt("{{cyan:    uri_base: \"https://openrouter.ai/api/v1\",}}")
+            puts ::CLI::UI.fmt("{{cyan:  )}}")
+          else
+            puts ::CLI::UI.fmt("{{cyan:require \"faraday\"}}")
+            puts ::CLI::UI.fmt("{{cyan:require \"faraday/retry\"}}")
+            puts
+            puts ::CLI::UI.fmt("{{cyan: Raix.configure do |config|}}")
+            puts ::CLI::UI.fmt("{{cyan:  config.openai_client = OpenAI::Client.new(}}")
+            puts ::CLI::UI.fmt("{{cyan:    access_token: ENV.fetch(\"OPENAI_API_KEY\"),}}")
+            puts ::CLI::UI.fmt("{{cyan:    uri_base: \"https://api.openai.com/v1\",}}")
+            puts ::CLI::UI.fmt("{{cyan:  ) do |f|}}")
+            puts ::CLI::UI.fmt("{{cyan:    f.request(:retry, {}}")
+            puts ::CLI::UI.fmt("{{cyan:      max: 2,}}")
+            puts ::CLI::UI.fmt("{{cyan:      interval: 0.05,}}")
+            puts ::CLI::UI.fmt("{{cyan:      interval_randomness: 0.5,}}")
+            puts ::CLI::UI.fmt("{{cyan:      backoff_factor: 2,}}")
+            puts ::CLI::UI.fmt("{{cyan:    })}}")
+            puts ::CLI::UI.fmt("{{cyan:  end}}")
+          end
+          puts ::CLI::UI.fmt("{{cyan:end}}")
+          puts
+          puts "For Shopify users, you need to use the LLM gateway proxy instead."
+          puts "Check the #roast slack channel for more information."
+          puts
+        end
+        raise ::CLI::Kit::Abort, "Please configure Raix before running workflows."
+      end
+
       def include_tools
         return unless @configuration.tools.present? || @configuration.mcp_tools.present?
 

data/lib/roast/workflow/workflow_runner.rb

@@ -167,6 +167,12 @@ module Roast
           workflow.verbose = @options[:verbose] if @options[:verbose].present?
           workflow.concise = @options[:concise] if @options[:concise].present?
           workflow.pause_step_name = @options[:pause] if @options[:pause].present?
+          # Set storage type based on CLI option (default is SQLite unless --file-storage is used)
+          workflow.storage_type = @options[:file_storage] ? "file" : nil
+          # Set model from configuration with fallback to default
+          workflow.model = @configuration.model || StepLoader::DEFAULT_MODEL
+          # Set context management configuration
+          workflow.context_management_config = @configuration.context_management
         end
       end