roast-ai 0.3.1 → 0.4.1

data/lib/roast.rb

@@ -1,24 +1,44 @@
 # frozen_string_literal: true
 
+# Standard library requires
+require "digest"
+require "English"
+require "erb"
+require "fileutils"
+require "json"
+require "logger"
+require "net/http"
+require "open3"
+require "pathname"
+require "securerandom"
+require "tempfile"
+require "uri"
+require "yaml"
+
+# Third-party gem requires
 require "active_support"
 require "active_support/cache"
-require "active_support/notifications"
 require "active_support/core_ext/hash/indifferent_access"
+require "active_support/core_ext/module/delegation"
 require "active_support/core_ext/string"
 require "active_support/core_ext/string/inflections"
-require "active_support/core_ext/module/delegation"
 require "active_support/isolated_execution_state"
-require "fileutils"
+require "active_support/notifications"
 require "cli/ui"
+require "diff/lcs"
+require "json-schema"
 require "raix"
+require "raix/chat_completion"
+require "raix/function_dispatch"
+require "ruby-graphviz"
 require "thor"
-require "roast/errors"
-require "roast/helpers"
-require "roast/initializers"
-require "roast/resources"
-require "roast/tools"
-require "roast/version"
-require "roast/workflow"
+
+# Autoloading setup
+require "zeitwerk"
+
+# Set up Zeitwerk autoloader
+loader = Zeitwerk::Loader.for_gem
+loader.setup
 
 module Roast
   ROOT = File.expand_path("../..", __FILE__)
@@ -31,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?
@@ -48,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}"
@@ -63,6 +122,149 @@ module Roast
       end
     end
 
+    desc "list", "List workflows visible to Roast and their source"
+    def list
+      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
+
+      puts "Available workflows:"
+      puts
+
+      workflow_files.each do |file|
+        workflow_name = File.dirname(file.sub("#{roast_dir}/", ""))
+        puts "  #{workflow_name} (from project)"
+      end
+
+      puts
+      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,18 +30,20 @@ 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-ui")
+  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("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": {
@@ -206,6 +282,52 @@
                 }
               },
               "required": ["case", "when"]
+            },
+            {
+              "type": "object",
+              "properties": {
+                "input": {
+                  "type": "object",
+                  "properties": {
+                    "prompt": {
+                      "type": "string",
+                      "description": "The prompt text to display to the user"
+                    },
+                    "name": {
+                      "type": "string",
+                      "description": "Optional name to store the input value in workflow state"
+                    },
+                    "type": {
+                      "type": "string",
+                      "enum": ["text", "boolean", "choice", "password"],
+                      "default": "text",
+                      "description": "The type of input to collect"
+                    },
+                    "required": {
+                      "type": "boolean",
+                      "default": false,
+                      "description": "Whether the input is required"
+                    },
+                    "default": {
+                      "description": "Default value for the input"
+                    },
+                    "timeout": {
+                      "type": "number",
+                      "description": "Optional timeout in seconds"
+                    },
+                    "options": {
+                      "type": "array",
+                      "items": {
+                        "type": "string"
+                      },
+                      "description": "Options for choice type inputs"
+                    }
+                  },
+                  "required": ["prompt"],
+                  "additionalProperties": false
+                }
+              },
+              "required": ["input"]
             }
           ]
         }