roast-ai 0.4.0 → 0.4.2

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

@@ -25,11 +25,13 @@ require "active_support/core_ext/string/inflections"
 require "active_support/isolated_execution_state"
 require "active_support/notifications"
 require "cli/ui"
+require "cli/kit"
 require "diff/lcs"
 require "json-schema"
 require "raix"
 require "raix/chat_completion"
 require "raix/function_dispatch"
+require "ruby-graphviz"
 require "thor"
 
 # Autoloading setup
@@ -50,6 +52,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 +70,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 +149,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,19 +30,22 @@ 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) }
   spec.require_paths = ["lib"]
 
   spec.add_dependency("activesupport", ">= 7.0")
+  spec.add_dependency("cli-kit", "~> 5.0")
   spec.add_dependency("cli-ui", "2.3.0")
   spec.add_dependency("diff-lcs", "~> 1.5")
   spec.add_dependency("faraday-retry")
   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("sqlite3", "~> 2.6")
   spec.add_dependency("thor", "~> 1.3")
   spec.add_dependency("zeitwerk", "~> 2.6")
 end

data/schema/workflow.json

@@ -8,7 +8,46 @@
       "tools": {
         "type": "array",
         "items": {
-          "type": "string"
+          "oneOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "object",
+              "additionalProperties": {
+                "type": "object",
+                "properties": {
+                  "url": {
+                    "type": "string"
+                  },
+                  "command": {
+                    "type": "string"
+                  },
+                  "args": {
+                    "type": "array",
+                    "items": {
+                      "type": "string"
+                    }
+                  },
+                  "env": {
+                    "type": "object"
+                  },
+                  "only": {
+                    "type": "array",
+                    "items": {
+                      "type": "string"
+                    }
+                  },
+                  "except": {
+                    "type": "array",
+                    "items": {
+                      "type": "string"
+                    }
+                  }
+                }
+              }
+            }
+          ]
         }
       },
       "target": {
@@ -23,6 +62,43 @@
         "type": "string",
         "description": "Default AI model to use for all steps in the workflow"
       },
+      "context_management": {
+        "type": "object",
+        "description": "Configuration for automatic context management and compaction",
+        "properties": {
+          "enabled": {
+            "type": "boolean",
+            "description": "Whether to enable context management",
+            "default": true
+          },
+          "strategy": {
+            "type": "string",
+            "description": "Compaction strategy to use when threshold is exceeded",
+            "enum": ["auto", "summarize", "prune", "none"],
+            "default": "auto"
+          },
+          "threshold": {
+            "type": "number",
+            "description": "Percentage of context window to trigger compaction (0.0 to 1.0)",
+            "minimum": 0.0,
+            "maximum": 1.0,
+            "default": 0.8
+          },
+          "max_tokens": {
+            "type": "integer",
+            "description": "Maximum number of tokens allowed in context (defaults to model's limit)",
+            "minimum": 1000
+          },
+          "retain_steps": {
+            "type": "array",
+            "description": "Step names to always keep in full when compacting",
+            "items": {
+              "type": "string"
+            }
+          }
+        },
+        "additionalProperties": false
+      },
       "inputs": {
         "type": "array",
         "items": {