roast-ai 0.4.10 → 0.5.0

data/lib/roast/dsl/system_cogs/repeat.rb

@@ -0,0 +1,242 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  module DSL
+    module SystemCogs
+      # Repeat cog for executing a scope multiple times in a loop
+      #
+      # Executes a named execution scope (defined with `execute(:name)`) repeatedly until
+      # a `break!` is called. The output from each iteration becomes the input value for
+      # the next iteration, allowing for iterative transformations.
+      class Repeat < SystemCog
+        # Configuration for the `repeat` cog
+        #
+        # Currently has no configuration options.
+        class Config < Cog::Config; end
+
+        # Parameters for the `repeat` cog
+        class Params < SystemCog::Params
+          # The name of the execution scope to invoke for each iteration
+          #
+          #: Symbol
+          attr_accessor :run
+
+          # Initialize parameters with the cog name and execution scope
+          #
+          #: (?Symbol?, run: Symbol) -> void
+          def initialize(name = nil, run:)
+            super(name)
+            @run = run
+          end
+        end
+
+        # Input for the `repeat` cog
+        #
+        # Provides the initial value to pass to the first iteration. Each subsequent iteration
+        # receives the output from the previous iteration as its value.
+        class Input < Cog::Input
+          # The initial value to pass to the first iteration
+          #
+          # This value will be passed to the execution scope on the first iteration. Subsequent
+          # iterations receive the output from the previous iteration. Required.
+          #
+          #: untyped
+          attr_accessor :value
+
+          # The starting index for the first iteration
+          #
+          # Defaults to `0`. This affects the index value passed to each iteration.
+          #
+          # Integer
+          attr_accessor :index
+
+          # The maximum number of iterations for which the loop may run
+          #
+          # Defaults to `nil`, meaning that no maximum iteration limit is applied
+          #
+          #: Integer?
+          attr_accessor :max_iterations
+
+          # Initialize the input with default values
+          #
+          #: () -> void
+          def initialize
+            super
+            @index = 0
+          end
+
+          # Validate that required input values are present
+          #
+          #: () -> void
+          def validate!
+            raise Cog::Input::InvalidInputError, "'value' is required" if value.nil? && !coerce_ran?
+            raise Cog::Input::InvalidInputError, "'max_iterations' must be >= 1 if present" if (max_iterations || 1) < 1
+          end
+
+          # Coerce the input from the return value of the input block
+          #
+          # Sets the value from the input block's return value if not already set directly.
+          #
+          #: (untyped) -> void
+          def coerce(input_return_value)
+            super
+            @value = input_return_value unless @value.present?
+          end
+        end
+
+        # Output from running the `repeat` cog
+        #
+        # Contains results from all iterations that ran. Provides access to the final value
+        # (output from the last iteration) as well as individual iteration results.
+        #
+        # #### See Also
+        # - `Roast::DSL::CogInputContext#collect` - retrieves all iteration outputs as an array (via `results`)
+        # - `Roast::DSL::CogInputContext#reduce` - reduces iteration outputs to a single value (via `results`)
+        class Output < Cog::Output
+          # Initialize the output with results for all iterations
+          #
+          #: (Array[ExecutionManager]) -> void
+          def initialize(execution_managers)
+            super()
+            @execution_managers = execution_managers
+          end
+
+          # Get the final output value from the last iteration
+          #
+          # This is the output from the last iteration before `break!` was called.
+          # Returns `nil` if no iterations ran.
+          #
+          # #### Usage
+          # ```ruby
+          # # Get the final result directly
+          # final = repeat!(:process)
+          # ```
+          #
+          # #### See Also
+          # - `last`
+          # - `results`
+          #
+          #: () -> untyped
+          def value
+            @execution_managers.last&.final_output
+          end
+
+          # Get the output from a specific iteration
+          #
+          # Returns a `Roast::DSL::SystemCogs::Call::Output` object for the iteration at the given index.
+          # Supports negative indices to count from the end (e.g., `-1` for the last iteration).
+          #
+          # #### Usage
+          # ```ruby
+          # # Access a specific iteration
+          # result = from(repeat!(:process).iteration(2))
+          #
+          # # Access with negative index
+          # result = from(repeat!(:process).iteration(-1))
+          # ```
+          #
+          # #### See Also
+          # - `first`
+          # - `last`
+          # - `value`
+          # - `Roast::DSL::CogInputContext#from`
+          #
+          #: (Integer) -> Call::Output
+          def iteration(index)
+            Call::Output.new(@execution_managers.fetch(index))
+          end
+
+          # Get the output from the first iteration
+          #
+          # Convenience method equivalent to `iteration(0)`.
+          #
+          # #### See Also
+          # - `iteration`
+          # - `last`
+          #
+          #: () -> Call::Output
+          def first
+            iteration(0)
+          end
+
+          # Get the output from the last iteration
+          #
+          # Convenience method equivalent to `iteration(-1)`. Returns the same value as
+          # calling `value`, but wrapped in a `Roast::DSL::SystemCogs::Call::Output` for use with `from`.
+          #
+          # #### See Also
+          # - `iteration`
+          # - `first`
+          # - `value`
+          #
+          #: () -> Call::Output
+          def last
+            iteration(-1)
+          end
+
+          # Get all iteration results as a `Roast::DSL::SystemCogs::Map::Output` object
+          #
+          # Returns a `Roast::DSL::SystemCogs::Map::Output` containing all iterations, which can be used with
+          # `collect` or `reduce` to process all iteration outputs.
+          #
+          # #### Usage
+          # ```ruby
+          # # Collect all iteration outputs
+          # all_results = collect(repeat!(:process).results)
+          #
+          # # Reduce all iteration outputs
+          # sum = reduce(repeat!(:process).results, 0) { |acc, output| acc + output }
+          # ```
+          #
+          # #### See Also
+          # - `value`
+          # - `Roast::DSL::CogInputContext#collect`
+          # - `Roast::DSL::CogInputContext#reduce`
+          # - `Roast::DSL::SystemCogs::Map::Output`
+          #
+          #: () -> Map::Output
+          def results
+            Map::Output.new(@execution_managers)
+          end
+        end
+
+        # @requires_ancestor: Roast::DSL::ExecutionManager
+        module Manager
+          private
+
+          #: (Params, ^(Cog::Input) -> untyped) -> SystemCogs::Repeat
+          def create_repeat_system_cog(params, input_proc)
+            SystemCogs::Repeat.new(params.name, input_proc) do |input|
+              input = input #: as Input
+              raise ExecutionManager::ExecutionScopeNotSpecifiedError unless params.run.present?
+
+              ems = [] #: Array[ExecutionManager]
+              scope_value = input.value.deep_dup
+              max_iterations = input.max_iterations
+              loop do
+                ems << em = ExecutionManager.new(
+                  @cog_registry,
+                  @config_manager,
+                  @all_execution_procs,
+                  @workflow_context,
+                  scope: params.run,
+                  scope_value: scope_value,
+                  scope_index: ems.length,
+                )
+                em.prepare!
+                em.run!
+                scope_value = em.final_output
+                break if max_iterations.present? && ems.length >= max_iterations
+              rescue ControlFlow::Break
+                # TODO: do something with the message passed to break!
+                break
+              end
+              Output.new(ems)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roast/dsl/workflow.rb

@@ -11,18 +11,22 @@ module Roast
       class InvalidCogReference < WorkflowError; end
 
       class << self
-        #: (String) -> void
-        def from_file(workflow_path)
-          workflow = new(workflow_path)
-          workflow.prepare!
-          workflow.start!
+        #: (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) -> void
-      def initialize(workflow_path)
-        @workflow_path = Pathname.new(workflow_path)
-        @workflow_definition = File.read(workflow_path)
+      #: (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]]
@@ -37,9 +41,10 @@ module Roast
         @preparing = true
         extract_dsl_procs!
         @config_manager = ConfigManager.new(@cog_registry, @config_procs)
-        @config_manager.prepare!
-        @execution_manager = ExecutionManager.new(@cog_registry, @config_manager, @execution_procs)
-        @execution_manager.prepare!
+        @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
@@ -50,7 +55,12 @@ module Roast
         raise WorkflowAlreadyStartedError if started? || completed?
 
         @started = true
-        @execution_manager.run!
+        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
 
@@ -74,12 +84,12 @@ module Roast
         @completed ||= false
       end
 
-      #: { () [self: ConfigContext] -> void } -> void
+      #: { () [self: Roast::DSL::ConfigContext] -> void } -> void
       def config(&block)
         @config_procs << block
       end
 
-      #: (?Symbol?) { () [self: ExecutionContext] -> void } -> void
+      #: (?Symbol?) { () [self: Roast::DSL::ExecutionContext] -> void } -> void
       def execute(scope = nil, &block)
         (@execution_procs[scope] ||= []) << block
       end
@@ -106,7 +116,7 @@ module Roast
       # but does not evaluate any of them individually yet.
       #: () -> void
       def extract_dsl_procs!
-        instance_eval(@workflow_definition)
+        instance_eval(@workflow_definition, @workflow_path.realpath.to_s, 1)
       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.10"
+  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"