roast-ai 0.4.0 → 0.4.1

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

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