roast-ai 0.4.9 → 0.5.0

data/lib/roast/dsl/workflow.rb

@@ -0,0 +1,123 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  module DSL
+    class Workflow
+      class WorkflowError < Roast::Error; end
+      class WorkflowNotPreparedError < WorkflowError; end
+      class WorkflowAlreadyPreparedError < WorkflowError; end
+      class WorkflowAlreadyStartedError < WorkflowError; end
+      class InvalidCogReference < WorkflowError; end
+
+      class << self
+        #: (String, WorkflowParams) -> void
+        def from_file(workflow_path, params)
+          Dir.mktmpdir("roast-") do |tmpdir|
+            workflow_context = WorkflowContext.new(params:, tmpdir:)
+            workflow = new(workflow_path, workflow_context)
+            workflow.prepare!
+            workflow.start!
+          end
+        end
+      end
+
+      #: (String, WorkflowContext) -> void
+      def initialize(workflow_path, workflow_context)
+        @workflow_path = Pathname.new(workflow_path) #: Pathname
+        @workflow_context = workflow_context #: WorkflowContext
+        @workflow_definition = File.read(workflow_path) #: String
+        @cog_registry = Cog::Registry.new #: Cog::Registry
+        @config_procs = [] #: Array[^() -> void]
+        @execution_procs = { nil: [] } #: Hash[Symbol?, Array[^() -> void]]
+        @config_manager = nil #: ConfigManager?
+        @execution_manager = nil #: ExecutionManager?
+      end
+
+      #: () -> void
+      def prepare!
+        raise WorkflowAlreadyPreparedError if preparing? || prepared?
+
+        @preparing = true
+        extract_dsl_procs!
+        @config_manager = ConfigManager.new(@cog_registry, @config_procs)
+        @config_manager.not_nil!.prepare!
+        # TODO: probably we should just not pass the params as the top-level scope value anymore
+        @execution_manager = ExecutionManager.new(@cog_registry, @config_manager.not_nil!, @execution_procs, @workflow_context, scope_value: @workflow_context.params)
+        @execution_manager.not_nil!.prepare!
+
+        @prepared = true
+      end
+
+      #: () -> void
+      def start!
+        raise WorkflowNotPreparedError unless @config_manager.present? && @execution_manager.present?
+        raise WorkflowAlreadyStartedError if started? || completed?
+
+        @started = true
+        begin
+          @execution_manager.run!
+        rescue ControlFlow::Break
+          # treat `break!` like `next!` in the top-level executor scope
+          # TODO: maybe do something with the message passed to break!
+        end
+        @completed = true
+      end
+
+      #: () -> bool
+      def preparing?
+        @preparing ||= false
+      end
+
+      #: () -> bool
+      def prepared?
+        @prepared ||= false
+      end
+
+      #: () -> bool
+      def started?
+        @started ||= false
+      end
+
+      #: () -> bool
+      def completed?
+        @completed ||= false
+      end
+
+      #: { () [self: Roast::DSL::ConfigContext] -> void } -> void
+      def config(&block)
+        @config_procs << block
+      end
+
+      #: (?Symbol?) { () [self: Roast::DSL::ExecutionContext] -> void } -> void
+      def execute(scope = nil, &block)
+        (@execution_procs[scope] ||= []) << block
+      end
+
+      def use(cogs = [], from: nil)
+        require from if from
+
+        Array.wrap(cogs).each do |cog_name|
+          path = @workflow_path.realdirpath.dirname.join("cogs/#{cog_name}")
+          require path.to_s if from.nil?
+
+          cog_class_name = cog_name.camelize
+          raise InvalidCogReference, "Expected #{cog_class_name} class, not found in #{path}" unless Object.const_defined?(cog_class_name)
+
+          cog_class = cog_class_name.constantize # rubocop:disable Sorbet/ConstantsFromStrings
+          @cog_registry.use(cog_class)
+        end
+      end
+
+      private
+
+      # Evaluate the top-level workflow definition
+      # This collects the procs passed to `config` and `execute` calls in the workflow definition,
+      # but does not evaluate any of them individually yet.
+      #: () -> void
+      def extract_dsl_procs!
+        instance_eval(@workflow_definition, @workflow_path.realpath.to_s, 1)
+      end
+    end
+  end
+end

data/lib/roast/dsl/workflow_context.rb

@@ -0,0 +1,20 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  module DSL
+    class WorkflowContext
+      #: WorkflowParams
+      attr_reader :params
+
+      #: String
+      attr_reader :tmpdir
+
+      #: (params: WorkflowParams, tmpdir: String) -> void
+      def initialize(params:, tmpdir:)
+        @params = params
+        @tmpdir = tmpdir
+      end
+    end
+  end
+end

data/lib/roast/dsl/workflow_params.rb

@@ -0,0 +1,24 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  module DSL
+    class WorkflowParams
+      #: Array[String]
+      attr_reader :targets
+
+      #: Array[Symbol]
+      attr_reader :args
+
+      #: Hash[Symbol, String]
+      attr_reader :kwargs
+
+      #: (Array[String], Array[Symbol], Hash[Symbol, String]) -> void
+      def initialize(targets, args, kwargs)
+        @targets = targets
+        @args = args
+        @kwargs = kwargs
+      end
+    end
+  end
+end

data/lib/roast/sorbet_runtime_stub.rb

@@ -0,0 +1,154 @@
+# typed: ignore
+# frozen_string_literal: true
+
+module T
+  class << self
+    def absurd(value); end
+    def all(type_a, type_b, *types); end
+    def any(type_a, type_b, *types); end
+    def attached_class; end
+    def class_of(klass); end
+    def enum(values); end
+    def nilable(type); end
+    def noreturn; end
+    def self_type; end
+    def type_alias(type = nil, &_blk); end
+    def type_parameter(name); end
+    def untyped; end
+
+    def assert_type!(value, _type, _checked: true)
+      value
+    end
+
+    def cast(value, _type, _checked: true)
+      value
+    end
+
+    def let(value, _type, _checked: true)
+      value
+    end
+
+    def must(arg, _msg = nil)
+      arg
+    end
+
+    def proc
+      T::Proc.new
+    end
+
+    def reveal_type(value)
+      value
+    end
+
+    def unsafe(value)
+      value
+    end
+  end
+
+  module Sig
+    def sig(arg0 = nil, &blk); end
+  end
+
+  module Helpers
+    def abstract!; end
+    def interface!; end
+    def final!; end
+    def sealed!; end
+    def mixes_in_class_methods(mod); end
+  end
+
+  module Generic
+    include(T::Helpers)
+
+    def type_parameters(*params); end
+    def type_member(variance = :invariant, fixed: nil, lower: nil, upper: BasicObject); end
+    def type_template(variance = :invariant, fixed: nil, lower: nil, upper: BasicObject); end
+
+    def [](*types)
+      self
+    end
+  end
+
+  module Array
+    class << self
+      def [](type); end
+    end
+  end
+
+  Boolean = Object.new.freeze
+
+  module Configuration
+    class << self
+      def call_validation_error_handler(signature, opts); end
+      def call_validation_error_handler=(value); end
+      def default_checked_level=(default_checked_level); end
+      def enable_checking_for_sigs_marked_checked_tests; end
+      def enable_final_checks_on_hooks; end
+      def enable_legacy_t_enum_migration_mode; end
+      def reset_final_checks_on_hooks; end
+      def hard_assert_handler(str, extra); end
+      def hard_assert_handler=(value); end
+      def inline_type_error_handler(error); end
+      def inline_type_error_handler=(value); end
+      def log_info_handler(str, extra); end
+      def log_info_handler=(value); end
+      def scalar_types; end
+      def scalar_types=(values); end
+      def sealed_violation_whitelist; end
+      def sealed_violation_whitelist=(sealed_violation_whitelist); end
+      def sig_builder_error_handler=(value); end
+      def sig_validation_error_handler(error, opts); end
+      def sig_validation_error_handler=(value); end
+      def soft_assert_handler(str, extra); end
+      def soft_assert_handler=(value); end
+    end
+  end
+
+  module Enumerable
+    class << self
+      def [](type); end
+    end
+  end
+
+  module Enumerator
+    class << self
+      def [](type); end
+    end
+  end
+
+  module Hash
+    class << self
+      def [](keys, values); end
+    end
+  end
+
+  class Proc
+    def bind(*_)
+      self
+    end
+
+    def params(*_param)
+      self
+    end
+
+    def void
+      self
+    end
+
+    def returns(_type)
+      self
+    end
+  end
+
+  module Range
+    class << self
+      def [](type); end
+    end
+  end
+
+  module Set
+    class << self
+      def [](type); end
+    end
+  end
+end

data/lib/roast/tools/apply_diff.rb

@@ -1,8 +1,6 @@
 # typed: false
 # frozen_string_literal: true
 
-require "cli/ui"
-
 module Roast
   module Tools
     module ApplyDiff
@@ -64,7 +62,7 @@ module Roast
           Roast::Helpers::Logger.info(cancel_msg + "\n")
           cancel_msg
         end
-      rescue Roast::Error => e
+      rescue Roast::Error, Errno::EACCES, Errno::ENOENT => e
         error_message = "Error applying diff: #{e.message}"
         Roast::Helpers::Logger.error(error_message + "\n")
         Roast::Helpers::Logger.debug(e.backtrace.join("\n") + "\n") if ENV["DEBUG"]

data/lib/roast/tools/cmd.rb

@@ -153,9 +153,10 @@ module Roast
         )
 
         format_output(command, result, status.exitstatus)
-      rescue Timeout::Error => e
-        Roast::Helpers::Logger.error(e.message + "\n")
-        e.message
+      rescue Timeout::Error, Errno::ENOENT => e
+        error_message = "Error running command: #{e.message}"
+        Roast::Helpers::Logger.error(error_message + "\n")
+        error_message
       end
 
       def format_output(command, result, exit_status)

data/lib/roast/tools/read_file.rb

@@ -39,7 +39,7 @@ module Roast
         else
           File.read(path)
         end
-      rescue Roast::Error => e
+      rescue Roast::Error, Errno::ENOENT, Errno::EACCES => e
         "Error reading file: #{e.message}".tap do |error_message|
           Roast::Helpers::Logger.error(error_message + "\n")
           Roast::Helpers::Logger.debug(e.backtrace.join("\n") + "\n") if ENV["DEBUG"]

data/lib/roast/tools/update_files.rb

@@ -306,7 +306,7 @@ module Roast
               if new_content_lines
                 content_lines = new_content_lines
               else
-                raise "Hunk could not be applied cleanly: #{hunk[:header]}"
+                raise Roast::Error, "Hunk could not be applied cleanly: #{hunk[:header]}"
               end
             end
 

data/lib/roast/tools/write_file.rb

@@ -49,7 +49,7 @@ module Roast
           Roast::Helpers::Logger.error(restriction_message)
           "Error: Path must start with '#{restrict_path}' to use the write_file tool, try again."
         end
-      rescue Roast::Error => e
+      rescue Roast::Error, Errno::EACCES, Errno::ENOENT => e
         "Error writing file: #{e.message}".tap do |error_message|
           Roast::Helpers::Logger.error(error_message + "\n")
           Roast::Helpers::Logger.debug(e.backtrace.join("\n") + "\n") if ENV["DEBUG"]

data/lib/roast/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Roast
-  VERSION = "0.4.9"
+  VERSION = "0.5.0"
 end

data/lib/roast/workflow/base_workflow.rb

@@ -175,7 +175,11 @@ module Roast
 
           if error_detail && !error_detail.empty? && !message.include?(error_detail)
             " (#{error_detail})"
+          else
+            ""
           end
+        else
+          ""
         end
 
         message

data/lib/roast/workflow/step_loader.rb

@@ -169,7 +169,14 @@ module Roast
           raise StepExecutionError.new("Syntax error in step file: #{e.message}", step_name: step_name, original_error: e)
         end
 
-        step_class = step_name.classify.constantize
+        step_class = if Object.const_defined?(step_name.camelize, false)
+          step_name.camelize.constantize
+        elsif Object.const_defined?(step_name.classify, false)
+          step_name.classify.constantize
+        else
+          raise StepExecutionError.new("No class named #{step_name.camelize} found in step file #{file_path}", step_name: step_name)
+        end
+
         context = File.dirname(file_path)
         # For Ruby steps, we instantiate the specific class directly
         # Convert step_name to StepName value object
@@ -208,7 +215,12 @@ module Roast
       def configure_step(step, step_name, is_last_step: nil)
         step_config = config_hash[step_name]
 
-        # Only set the model if explicitly specified for this step
+        # Apply global model if no step-specific model is configured
+        if config_hash.key?("model") && !step_config&.key?("model")
+          step.model = config_hash["model"]
+        end
+
+        # Apply step-specific model (overrides global model)
         step.model = step_config["model"] if step_config&.key?("model")
 
         # Pass resource to step if supported

data/lib/roast-ai.rb

@@ -0,0 +1,4 @@
+# typed: true
+# frozen_string_literal: true
+
+require "roast"

data/lib/roast.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 # Standard library requires
+require "benchmark"
 require "digest"
 require "English"
 require "erb"
@@ -11,6 +12,7 @@ require "logger"
 require "net/http"
 require "open3"
 require "pathname"
+require "pp"
 require "securerandom"
 require "shellwords"
 require "tempfile"
@@ -28,23 +30,37 @@ require "active_support/core_ext/string"
 require "active_support/core_ext/string/inflections"
 require "active_support/isolated_execution_state"
 require "active_support/notifications"
-require "cli/ui"
+require "async"
+require "async/semaphore"
 require "cli/kit"
+require "cli/ui"
 require "diff/lcs"
 require "json-schema"
 require "raix"
 require "raix/chat_completion"
 require "raix/function_dispatch"
 require "ruby-graphviz"
+require "ruby_llm"
 require "thor"
 require "timeout"
 
+unless defined?(T)
+  # NOTE: stubs for sorbet-runtime were being imported from cli-kit. They were removed in cli-kit v5.2
+  # Ideally we will not need them at all in the future, but for now I have brought them into the project
+  # because a large quantity of legacy code is using sorbet runtime assertions.
+  require("roast/sorbet_runtime_stub")
+end
+
+# Require project components that will not get automatically loaded
+require "roast/dsl/nil_assertions"
+
 # Autoloading setup
 require "zeitwerk"
 
 # Set up Zeitwerk autoloader
 loader = Zeitwerk::Loader.for_gem
 loader.inflector.inflect("dsl" => "DSL")
+loader.ignore("#{__dir__}/roast-ai.rb")
 loader.setup
 
 module Roast
@@ -59,7 +75,7 @@ module Roast
     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"
-    option :executor, type: :string, default: "default", desc: "Set workflow executor - experimental syntax"
+    option :executor, type: :string, default: "default", desc: "Set workflow executor (use 'dsl' for Roast 1.0 Feature Preview)"
 
     def execute(*paths)
       raise Thor::Error, "Workflow configuration file is required" if paths.empty?
@@ -67,8 +83,13 @@ module Roast
       workflow_path, *files = paths
 
       if options[:executor] == "dsl"
-        puts "⚠️ WARNING: This is an experimental syntax and may break at any time. Don't depend on it."
-        Roast::DSL::Executor.from_file(workflow_path)
+        $stderr.puts "⚠️ WARNING: You are using Roast 1.0 feature preview. This syntax has not yet been officially released and should not be considered fully stable."
+        targets, workflow_args, workflow_kwargs = parse_custom_workflow_args(files, ARGV)
+        targets.unshift(options[:target]) if options[:target]
+        workflow_params = Roast::DSL::WorkflowParams.new(targets, workflow_args, workflow_kwargs)
+        Dir.chdir(ENV["ROAST_WORKING_DIRECTORY"] || Dir.pwd) do
+          Roast::DSL::Workflow.from_file(workflow_path, workflow_params)
+        end
       else
         expanded_workflow_path = if workflow_path.include?("workflow.yml")
           File.expand_path(workflow_path)
@@ -286,6 +307,24 @@ module Roast
 
     private
 
+    #: (Array[String], Array[String]) -> [Array[String], Array[Symbol], Hash[Symbol, String]]
+    def parse_custom_workflow_args(parsed_args, raw_args)
+      separator_index = raw_args.index("--")
+      extra_args = (separator_index ? raw_args[(separator_index + 1)..] : []) || []
+      targets = parsed_args.shift(parsed_args.length - extra_args.length)
+      args = []
+      kwargs = {}
+      parsed_args.each do |arg|
+        if arg.include?("=")
+          key, value = arg.split("=", 2)
+          kwargs[key.to_sym] = value if key
+        else
+          args << arg.to_sym
+        end
+      end
+      [targets, args, kwargs]
+    end
+
     def show_example_picker
       examples = available_examples
 
@@ -295,7 +334,7 @@ module Roast
       end
 
       puts "Select an option:"
-      choices = ["Pick from examples", "New from prompt (beta)"]
+      choices = ["Pick from examples", "New from prompt (coming soon)"]
 
       selected = run_picker(choices, "Select initialization method:")
 
@@ -303,8 +342,8 @@ module Roast
       when "Pick from examples"
         example_choice = run_picker(examples, "Select an example:")
         copy_example(example_choice) if example_choice
-      when "New from prompt (beta)"
-        create_from_prompt
+      when "New from prompt (coming soon)"
+        show_coming_soon_message
       end
     end
 
@@ -348,22 +387,21 @@ module Roast
       puts "Successfully copied example '#{example_name}' to current directory."
     end
 
-    def create_from_prompt
-      puts("Create a new workflow from a description")
+    def show_coming_soon_message
+      puts
+      puts ::CLI::UI.fmt("{{bold:Workflow Generator - Coming Soon}}")
+      puts
+      puts "The 'New from prompt' workflow generator is being rebuilt to ensure"
+      puts "generated workflows are reliable and properly validated."
+      puts
+      puts "This feature will return with:"
+      puts "  • Better AI-generated workflow quality"
+      puts "  • Validation to ensure generated workflows actually work"
+      puts "  • Integration with Roast's upcoming DSL features"
+      puts
+      puts "For now, please use 'Pick from examples' to get started."
+      puts "You can then customize the example workflow for your needs."
       puts
-
-      # Execute the workflow generator
-      generator_path = File.join(Roast::ROOT, "examples", "workflow_generator", "workflow.yml")
-
-      begin
-        # Execute the workflow generator (it will handle user input)
-        Roast::Workflow::WorkflowRunner.new(generator_path, [], {}).begin!
-
-        puts
-        puts("Workflow generation complete!")
-      rescue => e
-        puts("Error generating workflow: #{e.message}")
-      end
     end
 
     class << self

data/{roast.gemspec → roast-ai.gemspec}

@@ -15,17 +15,10 @@ Gem::Specification.new do |spec|
   spec.homepage      = "https://github.com/Shopify/roast"
   spec.license       = "MIT"
 
-  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
-  # to allow pushing to a single host or delete this section to allow pushing to any host.
-  if spec.respond_to?(:metadata)
-    spec.metadata["allowed_push_host"] = "https://rubygems.org"
-    spec.metadata["homepage_uri"] = spec.homepage
-    spec.metadata["source_code_uri"] = "https://github.com/Shopify/roast"
-    spec.metadata["changelog_uri"] = "https://github.com/Shopify/roast/blob/main/CHANGELOG.md"
-  else
-    raise "RubyGems 2.0 or newer is required to protect against " \
-      "public gem pushes."
-  end
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/Shopify/roast"
+  spec.metadata["changelog_uri"] = "https://github.com/Shopify/roast/blob/main/CHANGELOG.md"
 
   # 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.
@@ -37,13 +30,17 @@ Gem::Specification.new do |spec|
   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("async", "~> 2.34")
+  spec.add_dependency("benchmark", "~> 0.4.1")
+  spec.add_dependency("cli-kit", "~> 5.2")
+  spec.add_dependency("cli-ui", "~> 2.7")
   spec.add_dependency("diff-lcs", "~> 1.5")
   spec.add_dependency("json-schema")
   spec.add_dependency("open_router", "~> 0.3")
   spec.add_dependency("raix", "~> 1.0.2")
+  spec.add_dependency("rake", "~> 13.3.0") # NOTE: required by Thor
   spec.add_dependency("ruby-graphviz", "~> 1.2")
+  spec.add_dependency("ruby_llm")
   spec.add_dependency("sqlite3", "~> 2.6")
   spec.add_dependency("thor", "~> 1.3")
   spec.add_dependency("zeitwerk", "~> 2.6")

data/sorbet/config

@@ -6,5 +6,6 @@
 --ignore=vendor/
 --ignore=test/
 --ignore=bin/
+--ignore=dsl/demo
 --enable-experimental-requires-ancestor
 --enable-experimental-rbs-comments