roast-ai 0.4.8 → 0.4.9

data/lib/roast/errors.rb

@@ -4,12 +4,12 @@
 module Roast
   module Errors
     # Custom error for API resource not found (404) responses
-    class ResourceNotFoundError < StandardError; end
+    class ResourceNotFoundError < Roast::Error; end
 
     # Custom error for when API authentication fails
-    class AuthenticationError < StandardError; end
+    class AuthenticationError < Roast::Error; end
 
     # Exit the app, for instance via Ctrl-C during an InputStep
-    class ExitEarly < StandardError; end
+    class ExitEarly < Roast::Error; end
   end
 end

data/lib/roast/graph/edge.rb

@@ -0,0 +1,25 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  class Graph
+    class Edge
+      #: (Node) -> void
+      attr_writer :join_node
+
+      attr_reader :from_node, :to_node
+
+      #: (Node, Node, ?proc: Proc?) -> void
+      def initialize(from_node, to_node, proc: nil)
+        @from_node = from_node
+        @to_node = to_node
+        @proc = proc # TODO: Shadowing proc builtin here
+      end
+
+      #: () -> String
+      def to_s
+        "#{@from_node} -> #{@to_node}"
+      end
+    end
+  end
+end

data/lib/roast/graph/node.rb

@@ -0,0 +1,40 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  class Graph
+    class Node
+      # class InvalidExecutableError < Roast::Error; end
+
+      attr_reader :name, :executable
+
+      #: (Symbol, ?executable: Proc | Graph | nil) -> void
+      def initialize(name, executable: nil)
+        @name = name
+        @executable = executable
+      end
+
+      #: () -> T::Boolean
+      def subgraph?
+        @executable.is_a?(Graph)
+      end
+
+      #: () -> T::Boolean
+      def done?
+        @name == :DONE
+      end
+
+      #: (Hash) -> void
+      def execute(state)
+        return if @executable.nil?
+
+        executable = @executable
+        if executable.is_a?(Proc)
+          executable.call(state)
+        elsif executable.is_a?(Graph)
+          executable.execute(state)
+        end
+      end
+    end
+  end
+end

data/lib/roast/graph/quantum_edge.rb

@@ -0,0 +1,27 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  class Graph
+    class QuantumEdge
+      #: (Roast::Graph::Node, Proc) -> void
+      def initialize(from_node, to_proc)
+        @from_node = from_node
+        @to_proc = to_proc
+      end
+
+      #: (Hash[untyped, untyped], Hash[Symbol, Roast::Graph::Node]) -> Array[Roast::Graph::Edge]
+      def collapse(state, nodes)
+        to_node_names = @to_proc.call(state)
+        to_node_names = to_node_names.is_a?(Array) ? to_node_names : [to_node_names]
+
+        to_node_names.map do |to_node_name|
+          to_node = nodes[to_node_name]
+          raise Error, "No node found with name #{to_node_name.inspect}" if to_node.nil?
+
+          Edge.new(@from_node, to_node)
+        end
+      end
+    end
+  end
+end

data/lib/roast/graph/threaded_exec.rb

@@ -0,0 +1,93 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  class Graph
+    class StateConflictError < Error; end
+
+    class ThreadedExec
+      def initialize(nodes, og_state)
+        @nodes = nodes
+        @og_state = og_state
+      end
+
+      #: () -> Hash[untyped, untyped]
+      def async_execute
+        states = threaded_execute(@nodes, @og_state)
+        merge_states!(@og_state, states)
+        @og_state
+      end
+
+      # Returns a hash of the new states for each node.
+      #: (Array[Node], Hash[untyped, untyped]) -> Hash[Symbol, Hash[untyped, untyped]]
+      def threaded_execute(nodes, og_state)
+        states = {}
+        threads = nodes.map do |current_node|
+          states[current_node.name] = og_state.dup
+          Thread.new do
+            current_node.execute(states[current_node.name])
+          end
+        end
+
+        threads.map(&:value)
+
+        states
+      end
+
+      #: (Hash, Hash) -> void
+      def merge_states!(orig_state, new_states)
+        orig_state.merge!(merge_new_states(orig_state, new_states))
+      end
+
+      # We merge all the new states together first so we can catch any keys that were modified by multiple threads.
+      #: (Hash[untyped, untyped], Hash[Symbol, Hash[untyped, untyped]]) -> Hash[untyped, untyped]
+      def merge_new_states(orig_state, new_states)
+        # We only care about what the threads have changes from the original state.
+        changed_states = changed_states(orig_state, new_states)
+
+        return {} if changed_states.empty?
+
+        # Grab some entry to be the one we merge all the other changes into.
+        base_node_name, base_changed_state = T.must(changed_states.shift)
+        base_node_name = T.cast(base_node_name, Symbol)
+        base_changed_state = T.cast(base_changed_state, T::Hash[T.untyped, T.untyped])
+
+        changed_states.each do |node_name, changed_state|
+          base_changed_state.merge!(changed_state) do |key, old_value, new_value|
+            raise_state_conflict(key, old_value, new_value, [base_node_name, node_name])
+          end
+        end
+
+        base_changed_state
+      end
+
+      #: (Hash, Hash[Symbol, Hash]) -> Hash[Symbol, Hash]
+      def changed_states(orig_state, new_states)
+        new_states.transform_values do |new_state|
+          changed_state_entries(orig_state, new_state)
+        end
+      end
+
+      # Filter new states content to only include keys that were modified by the new states.
+      #: (Hash, Hash) -> Hash
+      def changed_state_entries(orig_state, new_state)
+        new_state.reject do |key, value|
+          orig_state[key] == value
+        end
+      end
+
+      #: (Symbol, untyped, untyped, Array[Symbol]) -> void
+      def raise_state_conflict(key, old_value, new_value, conflicting_nodes)
+        raise StateConflictError, <<~CONFLICT.chomp
+          Parallel nodes modified the same state key.
+          Conflicting nodes: #{conflicting_nodes.join(", ")}
+          Key: :#{key}
+          Old value:
+          #{old_value.inspect}
+          New value:
+          #{new_value.inspect}
+        CONFLICT
+      end
+    end
+  end
+end

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.8"
+  VERSION = "0.4.9"
 end