roast-ai 0.4.0 → 0.4.1

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_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
 

data/lib/roast/workflow_diagram_generator.rb

@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+
+module Roast
+  class WorkflowDiagramGenerator
+    def initialize(workflow_config, workflow_file_path = nil)
+      @workflow_config = workflow_config
+      @workflow_file_path = workflow_file_path
+      @graph = GraphViz.new(:G, type: :digraph)
+      @node_counter = 0
+      @nodes = {}
+    end
+
+    def generate(custom_output_path = nil)
+      configure_graph
+      build_graph(@workflow_config.steps)
+
+      output_path = custom_output_path || generate_output_filename
+      @graph.output(png: output_path)
+      output_path
+    end
+
+    private
+
+    def configure_graph
+      @graph[:rankdir] = "TB"
+      @graph[:fontname] = "Helvetica"
+      @graph[:fontsize] = "12"
+      @graph[:bgcolor] = "white"
+      @graph[:pad] = "0.5"
+      @graph[:nodesep] = "0.7"
+      @graph[:ranksep] = "0.8"
+      @graph[:splines] = "spline"
+
+      # Default node styling
+      @graph.node[:shape] = "box"
+      @graph.node[:style] = "rounded,filled"
+      @graph.node[:fillcolor] = "#E8F4FD"
+      @graph.node[:color] = "#2563EB"
+      @graph.node[:fontname] = "Helvetica"
+      @graph.node[:fontsize] = "11"
+      @graph.node[:fontcolor] = "#1E293B"
+      @graph.node[:penwidth] = "1.5"
+      @graph.node[:height] = "0.6"
+      @graph.node[:margin] = "0.15"
+
+      # Edge styling
+      @graph.edge[:fontname] = "Helvetica"
+      @graph.edge[:fontsize] = "10"
+      @graph.edge[:color] = "#64748B"
+      @graph.edge[:penwidth] = "1.5"
+      @graph.edge[:arrowsize] = "0.8"
+    end
+
+    def build_graph(steps, parent_node = nil)
+      previous_node = parent_node
+
+      steps.each do |step|
+        current_node = process_step(step)
+
+        if previous_node && current_node
+          @graph.add_edges(previous_node, current_node)
+        end
+
+        previous_node = current_node unless current_node.nil?
+      end
+
+      previous_node
+    end
+
+    def process_step(step)
+      case step
+      when String
+        create_step_node(step)
+      when Hash
+        process_control_flow(step)
+      else
+        ::CLI::Kit.logger.warn("Unexpected step type in workflow diagram: #{step.class} - #{step.inspect}")
+        nil
+      end
+    end
+
+    def create_step_node(step_name)
+      node_id = next_node_id
+      label = step_name
+
+      # Check if it's an inline prompt
+      @nodes[node_id] = if step_name.start_with?("prompt:")
+        @graph.add_nodes(
+          node_id,
+          label: truncate_label(step_name[7..].strip),
+          fillcolor: "#FEF3C7",
+          color: "#F59E0B",
+          shape: "note",
+          fontsize: "10",
+        )
+      else
+        @graph.add_nodes(node_id, label: label)
+      end
+
+      @nodes[node_id]
+    end
+
+    def process_control_flow(control_flow)
+      if control_flow.key?("if") || control_flow.key?("unless")
+        process_conditional(control_flow)
+      elsif control_flow.key?("each") || control_flow.key?("repeat")
+        process_loop(control_flow)
+      elsif control_flow.key?("input")
+        process_input(control_flow)
+      elsif control_flow.key?("proceed?")
+        process_proceed(control_flow)
+      elsif control_flow.key?("case")
+        process_case(control_flow)
+      else
+        ::CLI::Kit.logger.warn("Unexpected control flow structure in workflow diagram: #{control_flow.keys.join(", ")}")
+        nil
+      end
+    end
+
+    def process_conditional(conditional)
+      condition_type = conditional.key?("if") ? "if" : "unless"
+      condition = conditional[condition_type]
+
+      # Create diamond decision node
+      decision_id = next_node_id
+      decision_node = @graph.add_nodes(
+        decision_id,
+        label: "#{condition_type}: #{condition}",
+        shape: "diamond",
+        fillcolor: "#FEE2E2",
+        color: "#DC2626",
+        fontsize: "10",
+        height: "0.8",
+        width: "1.2",
+      )
+
+      # Process then branch
+      if conditional["then"]
+        then_steps = Array(conditional["then"])
+        if then_steps.any?
+          build_graph(then_steps, decision_node)
+        end
+      end
+
+      # Process else branch
+      if conditional["else"]
+        else_steps = Array(conditional["else"])
+        if else_steps.any?
+          build_graph(else_steps, decision_node)
+        end
+      end
+
+      decision_node
+    end
+
+    def process_loop(loop_control)
+      loop_type = loop_control.key?("each") ? "each" : "repeat"
+      loop_value = loop_control[loop_type]
+
+      # Create loop node
+      loop_id = next_node_id
+      loop_label = loop_type == "each" ? "each: #{loop_value}" : "repeat: #{loop_value}"
+      loop_node = @graph.add_nodes(
+        loop_id,
+        label: loop_label,
+        shape: "box3d",
+        fillcolor: "#D1FAE5",
+        color: "#10B981",
+        fontsize: "10",
+        penwidth: "2",
+      )
+
+      # Process loop body
+      if loop_control["do"]
+        loop_steps = Array(loop_control["do"])
+        if loop_steps.any?
+          last_loop_node = build_graph(loop_steps, loop_node)
+          # Add back edge to show loop
+          @graph.add_edges(
+            last_loop_node,
+            loop_node,
+            style: "dashed",
+            label: "loop",
+            color: "#10B981",
+            fontcolor: "#10B981",
+            arrowhead: "empty",
+          )
+        end
+      end
+
+      loop_node
+    end
+
+    def process_input(input_control)
+      input_id = next_node_id
+      label = input_control["input"]
+      input_node = @graph.add_nodes(
+        input_id,
+        label: "input: #{label}",
+        shape: "parallelogram",
+        fillcolor: "#F3F4F6",
+        color: "#6B7280",
+        fontsize: "10",
+      )
+      input_node
+    end
+
+    def process_proceed(proceed_control)
+      proceed_id = next_node_id
+      proceed_node = @graph.add_nodes(
+        proceed_id,
+        label: "proceed?",
+        shape: "diamond",
+        fillcolor: "#FED7AA",
+        color: "#EA580C",
+        fontsize: "10",
+        height: "0.8",
+      )
+
+      # Process do branch if present
+      if proceed_control["do"]
+        proceed_steps = Array(proceed_control["do"])
+        if proceed_steps.any?
+          build_graph(proceed_steps, proceed_node)
+        end
+      end
+
+      proceed_node
+    end
+
+    def process_case(case_control)
+      case_id = next_node_id
+      case_node = @graph.add_nodes(
+        case_id,
+        label: "case: #{case_control["case"]}",
+        shape: "diamond",
+        fillcolor: "#E9D5FF",
+        color: "#9333EA",
+        fontsize: "10",
+        height: "0.8",
+        width: "1.5",
+      )
+
+      # Process when branches
+      case_control["when"].each do |condition, steps|
+        when_steps = Array(steps)
+        next if when_steps.none?
+
+        first_when_node = process_step(when_steps.first)
+        @graph.add_edges(
+          case_node,
+          first_when_node,
+          label: condition.to_s,
+          fontcolor: "#9333EA",
+        )
+
+        if when_steps.length > 1
+          build_graph(when_steps[1..], first_when_node)
+        end
+      end
+
+      case_node
+    end
+
+    def next_node_id
+      @node_counter += 1
+      "node_#{@node_counter}"
+    end
+
+    def truncate_label(text, max_length = 50)
+      return text if text.length <= max_length
+
+      "#{text[0...max_length]}..."
+    end
+
+    def generate_output_filename
+      if @workflow_file_path
+        # Get the directory and base name of the workflow file
+        dir = File.dirname(@workflow_file_path)
+        base = File.basename(@workflow_file_path, ".yml")
+
+        # Create the diagram filename in the same directory
+        File.join(dir, "#{base}.png")
+      else
+        # Fallback to workflow name if no file path provided
+        workflow_name = @workflow_config.name
+        sanitized_name = workflow_name
+          .downcase
+          .gsub(/[^a-z0-9]+/, "_")
+          .gsub(/^_|_$/, "")
+          .gsub(/_+/, "_")
+
+        sanitized_name = "workflow" if sanitized_name.empty?
+        "#{sanitized_name}_diagram.png"
+      end
+    end
+  end
+end

data/lib/roast.rb

@@ -30,6 +30,7 @@ require "json-schema"
 require "raix"
 require "raix/chat_completion"
 require "raix/function_dispatch"
+require "ruby-graphviz"
 require "thor"
 
 # Autoloading setup
@@ -50,6 +51,7 @@ module Roast
     option :target, type: :string, aliases: "-t", desc: "Override target files. Can be file path, glob pattern, or $(shell command)"
     option :replay, type: :string, aliases: "-r", desc: "Resume workflow from a specific step. Format: step_name or session_timestamp:step_name"
     option :pause, type: :string, aliases: "-p", desc: "Pause workflow after a specific step. Format: step_name"
+    option :file_storage, type: :boolean, aliases: "-f", desc: "Use filesystem storage for sessions instead of SQLite"
 
     def execute(*paths)
       raise Thor::Error, "Workflow configuration file is required" if paths.empty?
@@ -67,6 +69,44 @@ module Roast
       Roast::Workflow::ConfigurationParser.new(expanded_workflow_path, files, options.transform_keys(&:to_sym)).begin!
     end
 
+    desc "resume WORKFLOW_FILE", "Resume a paused workflow with an event"
+    option :event, type: :string, aliases: "-e", required: true, desc: "Event name to trigger"
+    option :session_id, type: :string, aliases: "-s", desc: "Specific session ID to resume (defaults to most recent)"
+    option :event_data, type: :string, desc: "JSON data to pass with the event"
+    def resume(workflow_path)
+      expanded_workflow_path = if workflow_path.include?("workflow.yml")
+        File.expand_path(workflow_path)
+      else
+        File.expand_path("roast/#{workflow_path}/workflow.yml")
+      end
+
+      unless File.exist?(expanded_workflow_path)
+        raise Thor::Error, "Workflow file not found: #{expanded_workflow_path}"
+      end
+
+      # Store the event in the session
+      repository = Workflow::StateRepositoryFactory.create
+
+      unless repository.respond_to?(:add_event)
+        raise Thor::Error, "Event resumption requires SQLite storage. Set ROAST_STATE_STORAGE=sqlite"
+      end
+
+      # Parse event data if provided
+      event_data = options[:event_data] ? JSON.parse(options[:event_data]) : nil
+
+      # Add the event to the session
+      session_id = options[:session_id]
+      repository.add_event(expanded_workflow_path, session_id, options[:event], event_data)
+
+      # Resume workflow execution from the wait state
+      resume_options = options.transform_keys(&:to_sym).merge(
+        resume_from_event: options[:event],
+        session_id: session_id,
+      )
+
+      Roast::Workflow::ConfigurationParser.new(expanded_workflow_path, [], resume_options).begin!
+    end
+
     desc "version", "Display the current version of Roast"
     def version
       puts "Roast version #{Roast::VERSION}"
@@ -108,6 +148,123 @@ module Roast
       puts "Run a workflow with: roast execute <workflow_name>"
     end
 
+    desc "validate [WORKFLOW_CONFIGURATION_FILE]", "Validate a workflow configuration"
+    option :strict, type: :boolean, aliases: "-s", desc: "Treat warnings as errors"
+    def validate(workflow_path = nil)
+      validation_command = Roast::Workflow::ValidationCommand.new(options)
+      validation_command.execute(workflow_path)
+    end
+
+    desc "sessions", "List stored workflow sessions"
+    option :status, type: :string, aliases: "-s", desc: "Filter by status (running, waiting, completed, failed)"
+    option :workflow, type: :string, aliases: "-w", desc: "Filter by workflow name"
+    option :older_than, type: :string, desc: "Show sessions older than specified time (e.g., '7d', '1h')"
+    option :cleanup, type: :boolean, desc: "Clean up old sessions"
+    def sessions
+      repository = Workflow::StateRepositoryFactory.create
+
+      unless repository.respond_to?(:list_sessions)
+        raise Thor::Error, "Session listing is only available with SQLite storage. Set ROAST_STATE_STORAGE=sqlite"
+      end
+
+      if options[:cleanup] && options[:older_than]
+        count = repository.cleanup_old_sessions(options[:older_than])
+        puts "Cleaned up #{count} old sessions"
+        return
+      end
+
+      sessions = repository.list_sessions(
+        status: options[:status],
+        workflow_name: options[:workflow],
+        older_than: options[:older_than],
+      )
+
+      if sessions.empty?
+        puts "No sessions found"
+        return
+      end
+
+      puts "Found #{sessions.length} session(s):"
+      puts
+
+      sessions.each do |session|
+        id, workflow_name, _, status, current_step, created_at, updated_at = session
+
+        puts "Session: #{id}"
+        puts "  Workflow: #{workflow_name}"
+        puts "  Status: #{status}"
+        puts "  Current step: #{current_step || "N/A"}"
+        puts "  Created: #{created_at}"
+        puts "  Updated: #{updated_at}"
+        puts
+      end
+    end
+
+    desc "session SESSION_ID", "Show details for a specific session"
+    def session(session_id)
+      repository = Workflow::StateRepositoryFactory.create
+
+      unless repository.respond_to?(:get_session_details)
+        raise Thor::Error, "Session details are only available with SQLite storage. Set ROAST_STATE_STORAGE=sqlite"
+      end
+
+      details = repository.get_session_details(session_id)
+
+      unless details
+        raise Thor::Error, "Session not found: #{session_id}"
+      end
+
+      session = details[:session]
+      states = details[:states]
+      events = details[:events]
+
+      puts "Session: #{session[0]}"
+      puts "Workflow: #{session[1]}"
+      puts "Path: #{session[2]}"
+      puts "Status: #{session[3]}"
+      puts "Created: #{session[6]}"
+      puts "Updated: #{session[7]}"
+
+      if session[5]
+        puts
+        puts "Final output:"
+        puts session[5]
+      end
+
+      if states && !states.empty?
+        puts
+        puts "Steps executed:"
+        states.each do |step_index, step_name, created_at|
+          puts "  #{step_index}: #{step_name} (#{created_at})"
+        end
+      end
+
+      if events && !events.empty?
+        puts
+        puts "Events:"
+        events.each do |event_name, event_data, received_at|
+          puts "  #{event_name} at #{received_at}"
+          puts "    Data: #{event_data}" if event_data
+        end
+      end
+    end
+
+    desc "diagram WORKFLOW_FILE", "Generate a visual diagram of a workflow"
+    option :output, type: :string, aliases: "-o", desc: "Output file path (defaults to workflow_name_diagram.png)"
+    def diagram(workflow_file)
+      unless File.exist?(workflow_file)
+        raise Thor::Error, "Workflow file not found: #{workflow_file}"
+      end
+
+      workflow = Workflow::Configuration.new(workflow_file)
+      generator = WorkflowDiagramGenerator.new(workflow, workflow_file)
+      output_path = generator.generate(options[:output])
+
+      puts ::CLI::UI.fmt("{{success:✓}} Diagram generated: #{output_path}")
+    rescue StandardError => e
+      raise Thor::Error, "Error generating diagram: #{e.message}"
+    end
+
     private
 
     def show_example_picker

data/roast.gemspec

@@ -30,7 +30,7 @@ Gem::Specification.new do |spec|
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files = Dir.chdir(File.expand_path("..", __FILE__)) do
-    %x(git ls-files -z).split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+    %x(git ls-files -z).split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) || f.end_with?(".gem") }
   end
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
@@ -43,6 +43,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency("json-schema")
   spec.add_dependency("open_router", "~> 0.3")
   spec.add_dependency("raix", "~> 1.0")
+  spec.add_dependency("ruby-graphviz", "~> 1.2")
   spec.add_dependency("thor", "~> 1.3")
   spec.add_dependency("zeitwerk", "~> 2.6")
 end