roast-ai 0.4.7 → 0.4.9

data/lib/roast/graph.rb

@@ -0,0 +1,233 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  class Graph
+    class Error < StandardError; end
+    class AddEdgeError < Error; end
+    class EdgeTopologyError < Error; end
+
+    #: (Symbol) { (Graph) -> void } -> void
+    def subgraph(name, &block)
+      subgraph = Graph.new
+      block.call(subgraph)
+      nodes[name] = Node.new(name, executable: subgraph)
+    end
+
+    #: (Symbol) { () -> void } -> void
+    def node(name, &block)
+      nodes[name] = Node.new(name, executable: block)
+    end
+
+    #: (from: Symbol | Array[Symbol], ?to: Symbol | Array[Symbol] | nil) ?{ () -> void } -> void
+    def edge(from:, to: nil, &block)
+      from_nodes = from.is_a?(Array) ? from.map { |from_node| nodes[from_node] } : [nodes[from]].compact
+
+      if from_nodes.empty?
+        raise AddEdgeError, "Cannot create edge from #{from.inspect} to #{to.inspect} because #{from.inspect} does not exist"
+      end
+
+      if block.nil? && !to.nil?
+        to_nodes = to.is_a?(Array) ? to.map { |to_node| nodes[to_node] } : [nodes[to]].compact
+
+        if to_nodes.empty?
+          raise AddEdgeError, "Cannot create edge from #{from.inspect} to #{to.inspect} because #{to.inspect} does not exist"
+        end
+
+        from_nodes.each do |from_node|
+          to_nodes.each do |to_node|
+            insert_edge(Edge.new(T.must(from_node), T.must(to_node)))
+          end
+        end
+      elsif !block.nil? && to.nil?
+        from_nodes.each do |from_node|
+          quantum_edges[T.must(from_node).name] = QuantumEdge.new(T.must(from_node), T.must(block))
+        end
+      elsif !block.nil? && !to.nil?
+        raise AddEdgeError, "Must provide either a to node or a block, not both"
+      else
+        raise AddEdgeError, "Must provide either a to node or a block"
+      end
+    end
+
+    #: (?Hash[untyped, untyped]?) -> void
+    def execute(init_state = nil)
+      return if nodes.empty?
+
+      # HACK: Move the DONE node to the end of the nodes array.
+      # In reality we should have a separate "ordered" representation of the nodes, and we store the
+      # main thing as a set.
+      nodes[:DONE] = T.must(nodes.delete(:DONE))
+
+      self.state = init_state unless init_state.nil?
+
+      current_nodes = T.let([T.must(nodes.values.first)], T::Array[Roast::Graph::Node])
+
+      until current_nodes.any? { |node| T.must(node).done? }
+        if current_nodes.size == 1
+          T.must(current_nodes.first).execute(state)
+        else
+          ThreadedExec.new(current_nodes, state).async_execute
+        end
+
+        current_nodes = find_next(current_nodes)
+      end
+    end
+
+    private
+
+    #: () -> Hash[Symbol, Node]
+    def nodes
+      @nodes ||= { START: Node.new(:START), DONE: Node.new(:DONE) }
+    end
+
+    #: () -> Hash[Symbol, Array[Edge]]
+    def edges
+      @edges ||= {}
+    end
+
+    #: () -> Hash[Symbol, Roast::Graph::QuantumEdge]
+    def quantum_edges
+      @quantum_edges ||= {}
+    end
+
+    #: () -> Hash
+    def state
+      @state ||= {}
+    end
+
+    #: (Hash) -> void
+    def state=(new_state)
+      raise Error, "State already set, cannot set it again" if !@state.nil? && !new_state.nil?
+
+      @state = new_state
+    end
+
+    #: (Array[Node]) -> Array[Node]
+    def find_next(current_nodes)
+      raise Error, "Somehow got an empty array of nodes" if current_nodes.empty?
+
+      collapse_quantum_edges(current_nodes)
+
+      next_edges = if current_nodes.size == 1
+        next_edges_for_node(T.must(current_nodes.first))
+      elsif current_nodes.size > 1
+        next_edges_for_nodes(current_nodes)
+      end
+
+      if next_edges.nil?
+        raise EdgeTopologyError, "No next edges found for #{current_nodes.map(&:name).join(", ")}, please define edges for this node"
+      end
+
+      next_nodes = next_edges.map(&:to_node).uniq
+
+      # If we're doing paralell nodes, we need to lookahead to ensuer we join back at the same node.
+      if next_nodes.size > 1
+        raise EdgeTopologyError, "Parallel execution many to many nodes is not supported" if current_nodes.size != 1
+
+        collapse_quantum_edges(next_nodes)
+        raise_unless_all_point_to_same_next_node?(next_nodes)
+      end
+
+      next_nodes
+    end
+
+    #: (Array[Node]) -> bool
+    def raise_unless_all_point_to_same_next_node?(nodes)
+      next_nodes = nodes.map { |node| edges_from(node) }.compact.flatten.map(&:to_node).uniq
+      # TODO: Deal with when next_nodes here is empty, should be generic "if you define any edges, you must define them all"
+      if next_nodes.size > 1
+        Roast::Helpers::Logger.info("Next nodes: #{next_nodes.map(&:name).join(", ")}")
+        raise EdgeTopologyError, "Parallel nodes #{nodes.map(&:name).join(", ")} have different next nodes: #{next_nodes.inspect}"
+      end
+
+      true
+    end
+
+    #: (Array[Node]) -> void
+    def collapse_quantum_edges(current_nodes)
+      curr_quantum_edges = current_nodes.map do |node|
+        quantum_edges[node.name]
+      end.compact
+
+      return if curr_quantum_edges.empty?
+
+      if curr_quantum_edges.size > 1
+        raise EdgeTopologyError, <<~MANY_Q_EDGES
+          Multiple quantum edges for nodes:
+          Nodes: #{current_nodes.map(&:name).join(", ")}"
+          Quantum Edges: #{quantum_edges.inspect}
+        MANY_Q_EDGES
+      end
+
+      edges = curr_quantum_edges.map do |quantum_edge|
+        quantum_edge.collapse(state, nodes)
+      end
+
+      edges.flatten.each do |edge|
+        insert_edge(edge)
+      end
+    end
+
+    #: (Node) -> Array[Edge]
+    def next_edges_for_node(current_node)
+      next_edges = edges_from(current_node)
+      # If the user never defined any edges, we'll just use the next node in the file.
+      next_edges ||= [edge_from_next_loaded(current_node.name)].compact if edges.empty?
+      T.must(next_edges)
+    end
+
+    #: (Array[Node]) -> Array[Edge]
+    def next_edges_for_nodes(current_nodes)
+      maybe_next_edges = current_nodes.map { |node| edges_from(node) }.compact.flatten
+
+      # Verify there are same number of edges as nodes.
+      if maybe_next_edges.size != current_nodes.size
+        raise EdgeTopologyError, <<~WRONG_NUM_EDGES
+          Parallel nodes have different numbers of edges:
+          Next Edges: #{maybe_next_edges}
+          Parallel nodes: #{current_nodes.map(&:name).join(", ")}
+        WRONG_NUM_EDGES
+      end
+
+      # Verify all the edges go to the same place.
+      uniq_to_nodes = maybe_next_edges.map(&:to_node).uniq!
+      if T.must(uniq_to_nodes).size != 1
+        # TODO: Present which edges are going to different places.
+        raise EdgeTopologyError, <<~WRONG_NUM_EDGES
+          Parallel nodes end up at different nodes:
+          Next Edges: #{maybe_next_edges}
+          Parallel nodes: #{current_nodes.map(&:name).join(", ")}
+        WRONG_NUM_EDGES
+      end
+
+      maybe_next_edges
+    end
+
+    #: (Node) -> Array[Edge]?
+    def edges_from(from_node)
+      edges[from_node.name]
+    end
+
+    #: (Edge) -> void
+    def insert_edge(edge)
+      edges[edge.from_node.name] ||= []
+      T.must(edges[edge.from_node.name]) << edge
+    end
+
+    #: (Symbol) -> Edge?
+    def edge_from_next_loaded(current_node_name)
+      next_node = next_loaded_node(current_node_name)
+      return if next_node.nil?
+
+      Edge.new(T.must(nodes[current_node_name]), next_node)
+    end
+
+    #: (Symbol) -> Node?
+    def next_loaded_node(current_node_name)
+      current_index = nodes.keys.index(current_node_name)
+      next_index = (T.must(current_index) + 1)
+      nodes.values[next_index]
+    end
+  end
+end

data/lib/roast/resources/api_resource.rb

@@ -74,7 +74,7 @@ module Roast
 
         # Consider 2xx and 3xx as success
         response.code.to_i < 400
-      rescue StandardError => e
+      rescue Roast::Error => e
         # Log the error but don't crash
         Roast::Helpers::Logger.error("Error checking API existence: #{e.message}")
         false
@@ -96,7 +96,7 @@ module Roast
           begin
             uri = URI.parse(target)
             Net::HTTP.get(uri)
-          rescue StandardError => e
+          rescue Roast::Error => e
             # Log the error but don't crash
             Roast::Helpers::Logger.error("Error fetching API contents: #{e.message}")
             nil

data/lib/roast/resources/url_resource.rb

@@ -23,7 +23,7 @@ module Roast
 
           # Consider 2xx and 3xx as success
           response.code.to_i < 400
-        rescue StandardError => e
+        rescue Roast::Error => e
           # Log the error but don't crash
           Roast::Helpers::Logger.error("Error checking URL existence: #{e.message}")
           false
@@ -36,7 +36,7 @@ module Roast
         begin
           uri = URI.parse(target)
           Net::HTTP.get(uri)
-        rescue StandardError => e
+        rescue Roast::Error => e
           # Log the error but don't crash
           Roast::Helpers::Logger.error("Error fetching URL contents: #{e.message}")
           nil

data/lib/roast/tools/apply_diff.rb

@@ -64,7 +64,7 @@ module Roast
           Roast::Helpers::Logger.info(cancel_msg + "\n")
           cancel_msg
         end
-      rescue StandardError => e
+      rescue Roast::Error => 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/ask_user.rb

@@ -28,7 +28,7 @@ module Roast
 
         Roast::Helpers::Logger.info("User responded: #{response}\n")
         response
-      rescue StandardError => e
+      rescue Roast::Error => e
         "Error getting user input: #{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/bash.rb

@@ -43,7 +43,7 @@ module Roast
       rescue Timeout::Error => e
         Roast::Helpers::Logger.error(e.message + "\n")
         e.message
-      rescue StandardError => e
+      rescue Roast::Error => e
         handle_error(e)
       end
 

data/lib/roast/tools/cmd.rb

@@ -93,7 +93,7 @@ module Roast
         Roast::Helpers::Logger.info("🔧 Running command: #{full_command}\n")
 
         execute_command(full_command, command_prefix, timeout)
-      rescue StandardError => e
+      rescue Roast::Error => e
         handle_error(e)
       end
 
@@ -108,7 +108,7 @@ module Roast
         command_prefix = command.split(" ").first
 
         execute_command(command, command_prefix, timeout)
-      rescue StandardError => e
+      rescue Roast::Error => e
         handle_error(e)
       end
 

data/lib/roast/tools/coding_agent.rb

@@ -7,7 +7,7 @@ module Roast
       extend self
       include Roast::Helpers::MetadataAccess
 
-      class CodingAgentError < StandardError; end
+      class CodingAgentError < Roast::Error; end
 
       CONFIG_CODING_AGENT_COMMAND = "coding_agent_command"
       private_constant :CONFIG_CODING_AGENT_COMMAND
@@ -59,7 +59,7 @@ module Roast
           Roast::Helpers::Logger.debug(e.backtrace.join("\n") + "\n") if ENV["DEBUG"]
         end
         Roast::Helpers::Logger.error("🤖 CodingAgent did not complete successfully after multiple retries")
-      rescue StandardError => e
+      rescue Roast::Error => e
         "🤖 Error running CodingAgent: #{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/grep.rb

@@ -47,7 +47,7 @@ module Roast
         else
           stdout
         end
-      rescue StandardError => e
+      rescue Roast::Error => e
         "Error grepping for string: #{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/read_file.rb

@@ -39,7 +39,7 @@ module Roast
         else
           File.read(path)
         end
-      rescue StandardError => e
+      rescue Roast::Error => 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/search_file.rb

@@ -44,7 +44,7 @@ module Roast
 
           results.map { |result| File.join(path, result) }.join("\n") # purposely give the AI list of actual paths so that it can read without searching first
         end
-      rescue StandardError => e
+      rescue Roast::Error => e
         "Error searching for '#{glob_pattern}' in '#{path}': #{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/swarm.rb

@@ -60,7 +60,7 @@ module Roast
         Roast::Helpers::Logger.info("🐝 Running Claude Swarm with config: #{config_path}\n")
 
         execute_swarm(prompt, config_path)
-      rescue StandardError => e
+      rescue Roast::Error => e
         handle_error(e)
       end
 

data/lib/roast/tools/update_files.rb

@@ -70,7 +70,7 @@ module Roast
 
         # Apply changes atomically
         apply_changes(file_changes, base_path, create_files)
-      rescue StandardError => e
+      rescue Roast::Error => e
         "Error applying patch: #{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"]
@@ -316,7 +316,7 @@ module Roast
           end
 
           "Successfully applied patch to #{modified_files.size} file(s): #{modified_files.join(", ")}"
-        rescue StandardError => e
+        rescue Roast::Error => e
           # Restore backups if any change fails
           backup_files.each do |path, content|
             File.write(path, content) if File.exist?(path)

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 StandardError => e
+      rescue Roast::Error => 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/tools.rb

@@ -24,7 +24,7 @@ module Roast
 
         #{File.read(file)}
       PROMPT
-    rescue StandardError => e
+    rescue Roast::Error => e
       Roast::Helpers::Logger.error("In current directory: #{Dir.pwd}\n")
       Roast::Helpers::Logger.error("Error reading file #{file}\n")
 

data/lib/roast/value_objects/api_token.rb

@@ -5,7 +5,7 @@ module Roast
   module ValueObjects
     # Value object representing an API token with validation
     class ApiToken
-      class InvalidTokenError < StandardError; end
+      class InvalidTokenError < Roast::Error; end
 
       attr_reader :value
 

data/lib/roast/value_objects/uri_base.rb

@@ -5,7 +5,7 @@ module Roast
   module ValueObjects
     # Value object representing a URI base with validation
     class UriBase
-      class InvalidUriBaseError < StandardError; end
+      class InvalidUriBaseError < Roast::Error; end
 
       attr_reader :value
 

data/lib/roast/value_objects/workflow_path.rb

@@ -5,7 +5,7 @@ module Roast
   module ValueObjects
     # Value object representing a workflow file path with validation and resolution
     class WorkflowPath
-      class InvalidPathError < StandardError; end
+      class InvalidPathError < Roast::Error; end
 
       attr_reader :value
 

data/lib/roast/version.rb

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

data/lib/roast/workflow/base_step.rb

@@ -10,10 +10,9 @@ module Roast
       delegate :append_to_final_output, :transcript, to: :workflow
       delegate_missing_to :workflow
 
-      # TODO: is this really the model we want to default to, and is this the right place to set it?
-      def initialize(workflow, model: "anthropic:claude-opus-4", name: nil, context_path: nil)
+      def initialize(workflow, model: nil, name: nil, context_path: nil)
         @workflow = workflow
-        @model = model
+        @model = model || workflow.model || StepLoader::DEFAULT_MODEL
         @name = normalize_name(name)
         @context_path = context_path || ContextPathResolver.resolve(self.class)
         @print_response = false

data/lib/roast/workflow/base_workflow.rb

@@ -113,7 +113,7 @@ module Roast
         log_and_raise_error(error, message, step_model || model, kwargs, execution_time)
       rescue => e
         execution_time = Time.now - start_time
-        log_and_raise_error(e, e.message, step_model || model, kwargs, execution_time)
+        log_and_raise_error(e, enhanced_message(e), step_model || model, kwargs, execution_time)
       end
 
       def with_model(model)
@@ -142,7 +142,43 @@ module Roast
           execution_time: execution_time,
         })
 
-        raise error
+        # If we have an enhanced message, create a new error with it
+        if message != error.message
+          new_error = error.class.new(message)
+          new_error.set_backtrace(error.backtrace) if error.backtrace
+          raise new_error
+        else
+          raise error
+        end
+      end
+
+      def enhanced_message(error)
+        original_message = error.message
+
+        url, status = if error.respond_to?(:response) && error.response.is_a?(Hash)
+          [error.response[:url], error.response[:status]]
+        elsif error.respond_to?(:response_status)
+          [nil, error.response_status]
+        end
+
+        message = if url && status
+          "API call to #{url} failed with status #{status}: #{original_message}"
+        elsif status
+          "API call failed with status #{status}: #{original_message}"
+        else
+          original_message
+        end
+
+        message += if error.respond_to?(:response_body)
+          body = error.response_body
+          error_detail = body.is_a?(Hash) ? body.dig("error", "message") : body.to_s
+
+          if error_detail && !error_detail.empty? && !message.include?(error_detail)
+            " (#{error_detail})"
+          end
+        end
+
+        message
       end
 
       def read_sidecar_prompt

data/lib/roast/workflow/command_executor.rb

@@ -4,7 +4,7 @@
 module Roast
   module Workflow
     class CommandExecutor
-      class CommandExecutionError < StandardError
+      class CommandExecutionError < Roast::Error
         attr_reader :command, :exit_status, :original_error, :output
 
         def initialize(message, command:, exit_status: nil, original_error: nil)

data/lib/roast/workflow/configuration_loader.rb

@@ -5,7 +5,7 @@ module Roast
   module Workflow
     # Handles loading and parsing of workflow configuration files
     class ConfigurationLoader
-      class ValidationError < StandardError; end
+      class ValidationError < Roast::Error; end
 
       class << self
         # Load configuration from a YAML file

data/lib/roast/workflow/error_handler.rb

@@ -27,7 +27,7 @@ module Roast
           current_attempt += 1
           result = block.call
           break
-        rescue StandardError => e
+        rescue Roast::Error => e
           remaining_attempts = maximum_attempts - current_attempt
           raise e if remaining_attempts == 0
 

data/lib/roast/workflow/step_executor_registry.rb

@@ -6,7 +6,7 @@ module Roast
     # Registry pattern for step executors - eliminates case statements
     # and follows Open/Closed Principle
     class StepExecutorRegistry
-      class UnknownStepTypeError < StandardError; end
+      class UnknownStepTypeError < Roast::Error; end
 
       @executors = {}
       @type_matchers = []

data/lib/roast/workflow/step_loader.rb

@@ -8,7 +8,7 @@ module Roast
       DEFAULT_MODEL = "gpt-4o-mini"
 
       # Custom exception classes
-      class StepLoaderError < StandardError
+      class StepLoaderError < Roast::Error
         attr_reader :step_name, :original_error
 
         def initialize(message, step_name: nil, original_error: nil)
@@ -208,8 +208,8 @@ module Roast
       def configure_step(step, step_name, is_last_step: nil)
         step_config = config_hash[step_name]
 
-        # Always set the model
-        step.model = determine_model(step_config)
+        # Only set the model if explicitly specified for this step
+        step.model = step_config["model"] if step_config&.key?("model")
 
         # Pass resource to step if supported
         step.resource = workflow.resource if step.respond_to?(:resource=)
@@ -223,11 +223,6 @@ module Roast
         end
       end
 
-      # Determine which model to use for the step
-      def determine_model(step_config)
-        step_config&.dig("model") || config_hash["model"] || DEFAULT_MODEL
-      end
-
       # Apply configuration settings to a step
       def apply_step_configuration(step, step_config)
         step.print_response = step_config["print_response"] if step_config.key?("print_response")

data/lib/roast/workflow/workflow_executor.rb

@@ -11,7 +11,7 @@ module Roast
     # by introducing the StepRunner interface.
     class WorkflowExecutor
       # Define custom exception classes for specific error scenarios
-      class WorkflowExecutorError < StandardError
+      class WorkflowExecutorError < Roast::Error
         attr_reader :step_name, :original_error
 
         def initialize(message, step_name: nil, original_error: nil)

data/lib/roast.rb

@@ -21,6 +21,7 @@ require "yaml"
 # Third-party gem requires
 require "active_support"
 require "active_support/cache"
+require "active_support/core_ext/array"
 require "active_support/core_ext/hash/indifferent_access"
 require "active_support/core_ext/module/delegation"
 require "active_support/core_ext/string"
@@ -279,7 +280,7 @@ module Roast
       output_path = generator.generate(options[:output])
 
       puts ::CLI::UI.fmt("{{success:✓}} Diagram generated: #{output_path}")
-    rescue StandardError => e
+    rescue Roast::Error => e
       raise Thor::Error, "Error generating diagram: #{e.message}"
     end
 
@@ -327,7 +328,11 @@ module Roast
     def copy_example(example_name)
       examples_dir = File.join(Roast::ROOT, "examples")
       source_path = File.join(examples_dir, example_name)
-      target_path = File.join(Dir.pwd, example_name)
+
+      # Always place new workflows in roast/ so `roast list` can find them
+      roast_dir = File.join(Dir.pwd, "roast")
+      FileUtils.mkdir_p(roast_dir)
+      target_path = File.join(roast_dir, example_name)
 
       unless File.directory?(source_path)
         puts "Example '#{example_name}' not found!"

data/sorbet/config

@@ -1,5 +1,7 @@
 --dir
 .
+--ignore=.git/
+--ignore=.idea/
 --ignore=tmp/
 --ignore=vendor/
 --ignore=test/

data/sorbet/rbi/annotations/.gitattributes

@@ -0,0 +1 @@
+**/*.rbi linguist-vendored=true