roast-ai 0.4.9 → 0.4.10

data/lib/roast/dsl/config_manager.rb

@@ -0,0 +1,96 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  module DSL
+    class ConfigManager
+      class ConfigManagerError < Roast::Error; end
+      class ConfigManagerNotPreparedError < ConfigManagerError; end
+      class ConfigManagerAlreadyPreparedError < ConfigManagerError; end
+
+      #: (Cog::Registry, Array[^() -> void]) -> void
+      def initialize(cog_registry, config_procs)
+        @cog_registry = cog_registry
+        @config_procs = config_procs
+        @config_context = ConfigContext.new #: ConfigContext
+        @general_configs = {} #: Hash[singleton(Cog), Cog::Config]
+        @name_scoped_configs = {} #: Hash[singleton(Cog), Hash[Symbol, Cog::Config]]
+      end
+
+      #: () -> void
+      def prepare!
+        raise ConfigManagerAlreadyPreparedError if preparing? || prepared?
+
+        @preparing = true
+        bind_registered_cogs
+        @config_procs.each { |cp| @config_context.instance_eval(&cp) }
+        @prepared = true
+      end
+
+      #: () -> bool
+      def preparing?
+        @preparing ||= false
+      end
+
+      #: () -> bool
+      def prepared?
+        @prepared ||= false
+      end
+
+      #: (singleton(Cog), ?Symbol?) -> Cog::Config
+      def config_for(cog_class, name = nil)
+        raise ConfigManagerNotPreparedError unless prepared?
+
+        # All cogs will always have a config; empty by default if the cog was never explicitly configured
+        config = fetch_general_config(cog_class)
+        name_scoped_config = fetch_name_scoped_config(cog_class, name) unless name.nil?
+        config = config.merge(name_scoped_config) if name_scoped_config
+        config
+      end
+
+      private
+
+      #: (singleton(Cog)) -> Cog::Config
+      def fetch_general_config(cog_class)
+        @general_configs[cog_class] ||= cog_class.config_class.new
+      end
+
+      #: (singleton(Cog), Symbol) -> Cog::Config
+      def fetch_name_scoped_config(cog_class, name)
+        name_scoped_configs_for_cog = @name_scoped_configs[cog_class] ||= {}
+        name_scoped_configs_for_cog[name] ||= cog_class.config_class.new
+      end
+
+      #: () -> void
+      def bind_registered_cogs
+        @cog_registry.cogs.each { |cog_method_name, cog_class| bind_cog(cog_method_name, cog_class) }
+      end
+
+      #: (Symbol, singleton(Cog)) -> void
+      def bind_cog(cog_method_name, cog_class)
+        on_config_method = method(:on_config)
+        cog_method = proc do |cog_name = nil, &cog_config_proc|
+          on_config_method.call(cog_class, cog_name, &cog_config_proc)
+        end
+        @config_context.instance_eval do
+          define_singleton_method(cog_method_name, cog_method)
+        end
+      end
+
+      #: (singleton(Cog), Symbol) { () -> void } -> void
+      def on_config(cog_class, cog_name, &cog_config_proc)
+        # Called when the cog method is invoked in the workflow's 'config' block.
+        # This allows configuration parameters to be set for the cog generally or for a specific named instance
+        config_object = if cog_name.nil?
+          fetch_general_config(cog_class)
+        else
+          fetch_name_scoped_config(cog_class, cog_name)
+        end
+        # NOTE: Sorbet expects the proc passed to instance_exec to be declared as taking an argument
+        # but our cog_config_proc does not get an argument
+        config_object.instance_exec(&T.unsafe(cog_config_proc)) if cog_config_proc
+        config_object
+      end
+    end
+  end
+end

data/lib/roast/dsl/execution_context.rb

@@ -0,0 +1,9 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  module DSL
+    # Context in which the `execute` blocks of a workflow definition are evaluated
+    class ExecutionContext; end
+  end
+end

data/lib/roast/dsl/execution_manager.rb

@@ -0,0 +1,137 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  module DSL
+    # Context in which the `execute` block of a workflow is evaluated
+    class ExecutionManager
+      class ExecutionManagerError < Roast::Error; end
+      class ExecutionManagerNotPreparedError < ExecutionManagerError; end
+      class ExecutionManagerAlreadyPreparedError < ExecutionManagerError; end
+      class ExecutionManagerCurrentlyRunningError < ExecutionManagerError; end
+      class ExecutionScopeDoesNotExistError < ExecutionManagerError; end
+      class ExecutionScopeNotSpecifiedError < ExecutionManagerError; end
+
+      #: (Cog::Registry, ConfigManager, Hash[Symbol?, Array[^() -> void]], ?Symbol?) -> void
+      def initialize(cog_registry, config_manager, all_execution_procs, scope = nil)
+        @cog_registry = cog_registry
+        @config_manager = config_manager
+        @all_execution_procs = all_execution_procs
+        @scope = scope
+        @cogs = Cog::Store.new #: Cog::Store
+        @cog_stack = Cog::Stack.new #: Cog::Stack
+        @execution_context = ExecutionContext.new #: ExecutionContext
+        @cog_input_manager = CogInputManager.new(@cog_registry, @cogs) #: CogInputManager
+      end
+
+      #: () -> void
+      def prepare!
+        raise ExecutionManagerAlreadyPreparedError if preparing? || prepared?
+
+        @preparing = true
+        bind_registered_cogs
+        my_execution_procs.each { |ep| @execution_context.instance_eval(&ep) }
+        @prepared = true
+      end
+
+      def run!
+        raise ExecutionManagerNotPreparedError unless prepared?
+        raise ExecutionManagerCurrentlyRunningError if running?
+
+        @running = true
+        @cog_stack.map do |name, cog|
+          cog.run!(
+            @config_manager.config_for(cog.class, name.to_sym),
+            cog_input_manager,
+          )
+        end
+        @running = false
+      end
+
+      #: () -> bool
+      def preparing?
+        @preparing ||= false
+      end
+
+      #: () -> bool
+      def prepared?
+        @prepared ||= false
+      end
+
+      #: () -> bool
+      def running?
+        @running ||= false
+      end
+
+      #: () -> CogInputContext
+      def cog_input_manager
+        raise ExecutionManagerNotPreparedError unless prepared?
+
+        @cog_input_manager.context
+      end
+
+      private
+
+      #: () -> Array[^() -> void]
+      def my_execution_procs
+        raise ExecutionScopeDoesNotExistError unless @all_execution_procs.key?(@scope)
+
+        @all_execution_procs[@scope] || []
+      end
+
+      #: (Symbol, Cog) -> void
+      def add_cog_instance(name, cog)
+        @cogs.insert(name, cog)
+        @cog_stack.push([name, cog])
+      end
+
+      # TODO: add typing for output
+      #: (Symbol) -> untyped
+      def output(name)
+        @cogs[name].output
+      end
+
+      #: () -> void
+      def bind_registered_cogs
+        @cog_registry.cogs.each { |cog_method_name, cog_class| bind_cog(cog_method_name, cog_class) }
+      end
+
+      #: (Symbol, singleton(Cog)) -> void
+      def bind_cog(cog_method_name, cog_class)
+        on_execute_method = method(:on_execute)
+        cog_method = proc do |cog_name = Random.uuid, &cog_input_proc|
+          on_execute_method.call(cog_class, cog_name, &cog_input_proc)
+        end
+        @execution_context.instance_eval do
+          define_singleton_method(cog_method_name, cog_method)
+        end
+      end
+
+      #: (singleton(Cog), Symbol) { (Cog::Input) -> untyped } -> void
+      def on_execute(cog_class, cog_name, &cog_input_proc)
+        # Called when the cog method is invoked in the workflow's 'execute' block.
+        # This creates the cog instance and prepares it for execution.
+        cog_instance = if cog_class == Cogs::Execute
+          create_special_execute_cog(cog_name, cog_input_proc)
+        else
+          cog_class.new(cog_name, cog_input_proc)
+        end
+        add_cog_instance(cog_name, cog_instance)
+      end
+
+      #: (Symbol, ^(Cogs::Execute::Input) -> untyped) -> Cogs::Execute
+      def create_special_execute_cog(cog_name, cog_input_proc)
+        trigger = proc do |input|
+          raise ExecutionScopeNotSpecifiedError unless input.scope.present?
+
+          em = ExecutionManager.new(@cog_registry, @config_manager, @all_execution_procs, input.scope)
+          em.prepare!
+          em.run!
+
+          # TODO: collect the outputs of the cogs in the execution manager that just ran and do something with them
+        end
+        Cogs::Execute.new(cog_name, cog_input_proc, trigger)
+      end
+    end
+  end
+end

data/lib/roast/dsl/workflow.rb

@@ -0,0 +1,113 @@
+# 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) -> void
+        def from_file(workflow_path)
+          workflow = new(workflow_path)
+          workflow.prepare!
+          workflow.start!
+        end
+      end
+
+      #: (String) -> void
+      def initialize(workflow_path)
+        @workflow_path = Pathname.new(workflow_path)
+        @workflow_definition = File.read(workflow_path)
+        @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.prepare!
+        @execution_manager = ExecutionManager.new(@cog_registry, @config_manager, @execution_procs)
+        @execution_manager.prepare!
+
+        @prepared = true
+      end
+
+      #: () -> void
+      def start!
+        raise WorkflowNotPreparedError unless @config_manager.present? && @execution_manager.present?
+        raise WorkflowAlreadyStartedError if started? || completed?
+
+        @started = true
+        @execution_manager.run!
+        @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: ConfigContext] -> void } -> void
+      def config(&block)
+        @config_procs << block
+      end
+
+      #: (?Symbol?) { () [self: 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)
+      end
+    end
+  end
+end

data/lib/roast/version.rb

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

data/lib/roast.rb

@@ -28,14 +28,15 @@ 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 "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"
 
@@ -68,7 +69,7 @@ module Roast
 
       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)
+        Roast::DSL::Workflow.from_file(workflow_path)
       else
         expanded_workflow_path = if workflow_path.include?("workflow.yml")
           File.expand_path(workflow_path)

data/roast.gemspec

@@ -44,6 +44,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency("open_router", "~> 0.3")
   spec.add_dependency("raix", "~> 1.0.2")
   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

data/sorbet/rbi/gems/marcel@1.1.0.rbi

@@ -0,0 +1,239 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `marcel` gem.
+# Please instead update this file by running `bin/tapioca gem marcel`.
+
+
+# This file is auto-generated. Instead of editing this file, please
+# add MIMEs to data/custom.xml or lib/marcel/mime_type/definitions.rb.
+#
+# source://marcel//lib/marcel.rb#3
+module Marcel; end
+
+# @private
+#
+# source://marcel//lib/marcel/tables.rb#9
+Marcel::EXTENSIONS = T.let(T.unsafe(nil), Hash)
+
+# @private
+#
+# source://marcel//lib/marcel/tables.rb#2513
+Marcel::MAGIC = T.let(T.unsafe(nil), Array)
+
+# Mime type detection
+#
+# source://marcel//lib/marcel/magic.rb#12
+class Marcel::Magic
+  # Mime type by type string
+  #
+  # @return [Magic] a new instance of Magic
+  #
+  # source://marcel//lib/marcel/magic.rb#16
+  def initialize(type); end
+
+  # Allow comparison with string
+  #
+  # @return [Boolean]
+  #
+  # source://marcel//lib/marcel/magic.rb#103
+  def ==(other); end
+
+  # @return [Boolean]
+  #
+  # source://marcel//lib/marcel/magic.rb#54
+  def audio?; end
+
+  # Returns true if type is child of parent type
+  #
+  # @return [Boolean]
+  #
+  # source://marcel//lib/marcel/magic.rb#58
+  def child_of?(parent); end
+
+  # Get mime comment
+  #
+  # source://marcel//lib/marcel/magic.rb#68
+  def comment; end
+
+  # Allow comparison with string
+  #
+  # @return [Boolean]
+  #
+  # source://marcel//lib/marcel/magic.rb#103
+  def eql?(other); end
+
+  # Get string list of file extensions
+  #
+  # source://marcel//lib/marcel/magic.rb#63
+  def extensions; end
+
+  # source://marcel//lib/marcel/magic.rb#107
+  def hash; end
+
+  # Mediatype shortcuts
+  #
+  # @return [Boolean]
+  #
+  # source://marcel//lib/marcel/magic.rb#53
+  def image?; end
+
+  # Returns the value of attribute mediatype.
+  #
+  # source://marcel//lib/marcel/magic.rb#13
+  def mediatype; end
+
+  # Returns the value of attribute subtype.
+  #
+  # source://marcel//lib/marcel/magic.rb#13
+  def subtype; end
+
+  # Returns true if type is a text format
+  #
+  # @return [Boolean]
+  #
+  # source://marcel//lib/marcel/magic.rb#50
+  def text?; end
+
+  # Return type as string
+  #
+  # source://marcel//lib/marcel/magic.rb#98
+  def to_s; end
+
+  # Returns the value of attribute type.
+  #
+  # source://marcel//lib/marcel/magic.rb#13
+  def type; end
+
+  # @return [Boolean]
+  #
+  # source://marcel//lib/marcel/magic.rb#55
+  def video?; end
+
+  class << self
+    # Add custom mime type. Arguments:
+    # * <i>type</i>: Mime type
+    # * <i>options</i>: Options hash
+    #
+    # Option keys:
+    # * <i>:extensions</i>: String list or single string of file extensions
+    # * <i>:parents</i>: String list or single string of parent mime types
+    # * <i>:magic</i>: Mime magic specification
+    # * <i>:comment</i>: Comment string
+    #
+    # source://marcel//lib/marcel/magic.rb#30
+    def add(type, options); end
+
+    # Lookup all mime types by magic content analysis.
+    # This is a slower operation.
+    #
+    # source://marcel//lib/marcel/magic.rb#93
+    def all_by_magic(io); end
+
+    # Lookup mime type by file extension
+    #
+    # source://marcel//lib/marcel/magic.rb#73
+    def by_extension(ext); end
+
+    # Lookup mime type by magic content analysis.
+    # This is a slow operation.
+    #
+    # source://marcel//lib/marcel/magic.rb#86
+    def by_magic(io); end
+
+    # Lookup mime type by filename
+    #
+    # source://marcel//lib/marcel/magic.rb#80
+    def by_path(path); end
+
+    # @return [Boolean]
+    #
+    # source://marcel//lib/marcel/magic.rb#113
+    def child?(child, parent); end
+
+    # Removes a mime type from the dictionary.  You might want to do this if
+    # you're seeing impossible conflicts (for instance, application/x-gmc-link).
+    # * <i>type</i>: The mime type to remove.  All associated extensions and magic are removed too.
+    #
+    # source://marcel//lib/marcel/magic.rb#42
+    def remove(type); end
+
+    private
+
+    # source://marcel//lib/marcel/magic.rb#117
+    def magic_match(io, method); end
+
+    # source://marcel//lib/marcel/magic.rb#127
+    def magic_match_io(io, matches, buffer); end
+  end
+end
+
+# source://marcel//lib/marcel/mime_type.rb#4
+class Marcel::MimeType
+  class << self
+    # source://marcel//lib/marcel/mime_type.rb#8
+    def extend(type, extensions: T.unsafe(nil), parents: T.unsafe(nil), magic: T.unsafe(nil)); end
+
+    # Returns the most appropriate content type for the given file.
+    #
+    # The first argument should be a +Pathname+ or an +IO+. If it is a +Pathname+, the specified
+    # file will be opened first.
+    #
+    # Optional parameters:
+    # * +name+: file name, if known
+    # * +extension+: file extension, if known
+    # * +declared_type+: MIME type, if known
+    #
+    # The most appropriate type is determined by the following:
+    # * type declared by binary magic number data
+    # * type declared by the first of file name, file extension, or declared MIME type
+    #
+    # If no type can be determined, then +application/octet-stream+ is returned.
+    #
+    # source://marcel//lib/marcel/mime_type.rb#29
+    def for(pathname_or_io = T.unsafe(nil), name: T.unsafe(nil), extension: T.unsafe(nil), declared_type: T.unsafe(nil)); end
+
+    private
+
+    # source://marcel//lib/marcel/mime_type.rb#36
+    def for_data(pathname_or_io); end
+
+    # source://marcel//lib/marcel/mime_type.rb#62
+    def for_declared_type(declared_type); end
+
+    # source://marcel//lib/marcel/mime_type.rb#54
+    def for_extension(extension); end
+
+    # source://marcel//lib/marcel/mime_type.rb#46
+    def for_name(name); end
+
+    # For some document types (notably Microsoft Office) we recognise the main content
+    # type with magic, but not the specific subclass. In this situation, if we can get a more
+    # specific class using either the name or declared_type, we should use that in preference
+    #
+    # source://marcel//lib/marcel/mime_type.rb#89
+    def most_specific_type(*candidates); end
+
+    # source://marcel//lib/marcel/mime_type.rb#79
+    def parse_media_type(content_type); end
+
+    # source://marcel//lib/marcel/mime_type.rb#71
+    def with_io(pathname_or_io, &block); end
+  end
+end
+
+# source://marcel//lib/marcel/mime_type.rb#5
+Marcel::MimeType::BINARY = T.let(T.unsafe(nil), String)
+
+# @private
+#
+# source://marcel//lib/marcel/tables.rb#1310
+Marcel::TYPE_EXTS = T.let(T.unsafe(nil), Hash)
+
+# Cooltalk Audio
+#
+# source://marcel//lib/marcel/tables.rb#2239
+Marcel::TYPE_PARENTS = T.let(T.unsafe(nil), Hash)
+
+# source://marcel//lib/marcel/version.rb#4
+Marcel::VERSION = T.let(T.unsafe(nil), String)