roast-ai 0.4.9 → 0.5.0

data/dsl/next_break.rb

@@ -0,0 +1,40 @@
+# typed: true
+# frozen_string_literal: true
+
+#: self as Roast::DSL::Workflow
+
+config do
+end
+
+execute do
+  map(:loop, run: :loop_body) { 1..3 }
+
+  ruby do
+    results = collect(map!(:loop)) do
+      [ruby?(:one), ruby?(:two), ruby?(:three)]
+    end
+    results.each_with_index do |iteration_results, index|
+      puts "Iteration #{index}: #{iteration_results.presence || "did not run at all"}"
+    end
+  end
+end
+
+execute(:loop_body) do
+  ruby(:one) do |_, _, idx|
+    skip! if idx == 0
+    s = "[#{idx}] beginning"
+    puts s
+    s
+  end
+  ruby(:two) do |_, _, idx|
+    break! if idx == 1
+    s = "[#{idx}] middle"
+    puts s
+    s
+  end
+  ruby(:three) do |_, _, idx|
+    s = "[#{idx}] end"
+    puts s
+    s
+  end
+end

data/dsl/next_break_parallel.rb

@@ -0,0 +1,44 @@
+# typed: true
+# frozen_string_literal: true
+
+#: self as Roast::DSL::Workflow
+
+config do
+  map { parallel! }
+end
+
+execute do
+  map(:loop, run: :loop_body) { 1..3 }
+
+  ruby do
+    results = collect(map!(:loop)) do
+      [ruby?(:one), ruby?(:two), ruby?(:three)]
+    end
+    results.each_with_index do |iteration_results, index|
+      puts "Iteration #{index}: #{iteration_results.presence || "did not run at all"}"
+    end
+  end
+end
+
+execute(:loop_body) do
+  ruby(:one) do |_, _, idx|
+    sleep(0.1) if idx == 0
+    sleep(0.2) if idx == 1
+    skip! if idx == 0
+    s = "[#{idx}] beginning"
+    puts s
+    s
+  end
+  ruby(:two) do |_, _, idx|
+    break! if idx == 1
+    s = "[#{idx}] middle"
+    puts s
+    s
+  end
+  ruby(:three) do |_, _, idx|
+    sleep(0.3) if idx == 2
+    s = "[#{idx}] end"
+    puts s
+    s
+  end
+end

data/dsl/outputs.rb

@@ -0,0 +1,39 @@
+# typed: true
+# frozen_string_literal: true
+
+#: self as Roast::DSL::Workflow
+
+config do
+  cmd { display! }
+  cmd(/to_/) { no_display! }
+end
+
+execute(:capitalize_a_word) do
+  cmd(:to_original) { |_, word| "echo \"#{word}\"" }
+  cmd(:to_upper) do |my, word|
+    my.command = "sh"
+    my.args << "-c"
+    my.args << "echo \"#{word}\" | tr '[:lower:]' '[:upper:]'"
+  end
+  cmd(:to_lower) do |my, word|
+    break! # the `outputs` will always be evaluated even if a cog breaks out of the execution scope
+    my.command = "sh"
+    my.args << "-c"
+    my.args << "echo \"#{word}\" | tr '[:upper:]' '[:lower:]'"
+  end
+  outputs do |word|
+    "Upper: #{cmd!(:to_upper).text} - Original: #{word}"
+    # `outputs` can return any kind of value
+  end
+end
+
+execute do
+  # Call a subroutine with `call` or `map`
+  call(:hello, run: :capitalize_a_word) { "Hello" }
+
+  cmd do
+    from_outputs = from(call!(:hello))
+    explicit_value_access = from(call!(:hello)) { cmd!(:to_upper).text }
+    "echo From Outputs: '\"#{from_outputs}\"\nExplicit Value Access: \"#{explicit_value_access}\"'"
+  end
+end

data/dsl/outputs_bang.rb

@@ -0,0 +1,36 @@
+# typed: true
+# frozen_string_literal: true
+
+#: self as Roast::DSL::Workflow
+
+config do
+  cmd { display! }
+  cmd(/to_/) { no_display! }
+end
+
+execute(:subroutine1) do
+  ruby(:one) { "one" }
+  ruby(:two) { skip! }
+  # Attempting to access the output of a cog that did not run will not raise an exception inside the `outputs` block
+  # Instead, it will just return `nil`
+  outputs { ruby!(:two).value }
+end
+
+execute(:subroutine2) do
+  ruby(:one) { "one" }
+  ruby(:two) { skip! }
+  # Attempting to access the output of a cog that did not run *will* raise an exception inside the `outputs!` block
+  outputs! do
+    puts "❗️ This block is expected to raise an exception ❗️"
+    ruby!(:two).value
+  end
+end
+
+execute do
+  call(:one, run: :subroutine1) {}
+
+  ruby { puts "Using the `outputs` block should return `nil`: #{from(call!(:one)) || "nil"}" }
+
+  # The `outputs!` block in subroutine2 will raise an exception as soon as it is evaluated
+  call(:two, run: :subroutine2) {}
+end

data/dsl/parallel_map.rb

@@ -0,0 +1,37 @@
+# typed: true
+# frozen_string_literal: true
+
+#: self as Roast::DSL::Workflow
+
+config do
+  cmd { display! }
+  map(:words) do
+    # By default, maximum parallelism is 1 and map executions will run synchronously
+    # Calling `parallel` with a larger value will allow multiple map items to be run in parallel, up to the limit given
+    # Calling `parallel!` or `parallel(0)` will allow unlimited parallelism, processing all map items in parallel
+    parallel 3
+  end
+end
+
+execute(:capitalize_a_word) do
+  cmd(:to_upper) do |_, word, index|
+    sleep(0.1) if index == 3 # "three" will be slow --> finishing second last
+    sleep(0.2) if index == 1 # "one" will be slowest --> finishing last
+    ["sh", "-c", "echo \"#{word}\" | tr '[:lower:]' '[:upper:]'"]
+  end
+end
+
+execute do
+  # Call a subroutine with `map`
+  map(:words, run: :capitalize_a_word) do |my|
+    my.items = ["one", "two", "three", "four", "five", "six"]
+    my.initial_index = 1 # for convenience, just because our items begin with "one"
+  end
+
+  cmd do |my|
+    my.command = "echo"
+    # Regardless of the order in which the items were processed by a parallel map,
+    # their results will always be provided to `collect` and `reduce` in the order in which they were given.
+    my.args << collect(map!(:words)) { cmd!(:to_upper).text }.join(", ")
+  end
+end

data/dsl/plugin-gem-example/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/dsl/plugin-gem-example/Gemfile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in plugin-gem-example.gemspec
+gemspec
+
+gem "irb"
+gem "rake", "~> 13.0"
+
+gem "minitest", "~> 5.16"
+
+gem "rubocop", "~> 1.21"

data/dsl/plugin-gem-example/Gemfile.lock

@@ -0,0 +1,178 @@
+PATH
+  remote: .
+  specs:
+    plugin-gem-example (0.1.0)
+      roast-ai
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (8.0.3)
+      base64
+      benchmark (>= 0.3)
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.3.1)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      logger (>= 1.4.2)
+      minitest (>= 5.1)
+      securerandom (>= 0.3)
+      tzinfo (~> 2.0, >= 2.0.5)
+      uri (>= 0.13.1)
+    addressable (2.8.7)
+      public_suffix (>= 2.0.2, < 7.0)
+    ast (2.4.3)
+    base64 (0.3.0)
+    benchmark (0.4.1)
+    bigdecimal (3.3.1)
+    cli-kit (5.0.1)
+      cli-ui (~> 2.0)
+    cli-ui (2.3.0)
+    concurrent-ruby (1.3.5)
+    connection_pool (2.5.4)
+    date (3.4.1)
+    diff-lcs (1.6.2)
+    dotenv (3.1.8)
+    drb (2.2.3)
+    erb (5.1.1)
+    event_stream_parser (1.0.0)
+    faraday (2.14.0)
+      faraday-net_http (>= 2.0, < 3.5)
+      json
+      logger
+    faraday-multipart (1.1.1)
+      multipart-post (~> 2.0)
+    faraday-net_http (3.4.1)
+      net-http (>= 0.5.0)
+    faraday-retry (2.3.2)
+      faraday (~> 2.0)
+    i18n (1.14.7)
+      concurrent-ruby (~> 1.0)
+    io-console (0.8.1)
+    irb (1.15.2)
+      pp (>= 0.6.0)
+      rdoc (>= 4.0.0)
+      reline (>= 0.4.2)
+    json (2.15.1)
+    json-schema (6.0.0)
+      addressable (~> 2.8)
+      bigdecimal (~> 3.1)
+    language_server-protocol (3.17.0.5)
+    lint_roller (1.1.0)
+    logger (1.7.0)
+    minitest (5.26.0)
+    multipart-post (2.4.1)
+    net-http (0.6.0)
+      uri
+    open_router (0.3.3)
+      activesupport (>= 6.0)
+      dotenv (>= 2)
+      faraday (>= 1)
+      faraday-multipart (>= 1)
+    ostruct (0.6.3)
+    parallel (1.27.0)
+    parser (3.3.9.0)
+      ast (~> 2.4.1)
+      racc
+    pp (0.6.3)
+      prettyprint
+    prettyprint (0.2.0)
+    prism (1.6.0)
+    psych (5.2.6)
+      date
+      stringio
+    public_suffix (6.0.2)
+    racc (1.8.1)
+    rainbow (3.1.1)
+    raix (1.0.3)
+      activesupport (>= 6.0)
+      faraday-retry (~> 2.0)
+      open_router (~> 0.2)
+      ostruct
+      ruby-openai (~> 8.1)
+    rake (13.3.0)
+    rdoc (6.15.0)
+      erb
+      psych (>= 4.0.0)
+      tsort
+    regexp_parser (2.11.3)
+    reline (0.6.2)
+      io-console (~> 0.5)
+    rexml (3.4.4)
+    roast-ai (0.4.9)
+      activesupport (>= 7.0)
+      cli-kit (~> 5.0)
+      cli-ui (= 2.3.0)
+      diff-lcs (~> 1.5)
+      json-schema
+      open_router (~> 0.3)
+      raix (~> 1.0.2)
+      ruby-graphviz (~> 1.2)
+      sqlite3 (~> 2.6)
+      thor (~> 1.3)
+      zeitwerk (~> 2.6)
+    rubocop (1.81.1)
+      json (~> 2.3)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.1.0)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.47.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.47.1)
+      parser (>= 3.3.7.2)
+      prism (~> 1.4)
+    ruby-graphviz (1.2.5)
+      rexml
+    ruby-openai (8.3.0)
+      event_stream_parser (>= 0.3.0, < 2.0.0)
+      faraday (>= 1)
+      faraday-multipart (>= 1)
+    ruby-progressbar (1.13.0)
+    securerandom (0.4.1)
+    sqlite3 (2.7.4-aarch64-linux-gnu)
+    sqlite3 (2.7.4-aarch64-linux-musl)
+    sqlite3 (2.7.4-arm-linux-gnu)
+    sqlite3 (2.7.4-arm-linux-musl)
+    sqlite3 (2.7.4-arm64-darwin)
+    sqlite3 (2.7.4-x86-linux-gnu)
+    sqlite3 (2.7.4-x86-linux-musl)
+    sqlite3 (2.7.4-x86_64-darwin)
+    sqlite3 (2.7.4-x86_64-linux-gnu)
+    sqlite3 (2.7.4-x86_64-linux-musl)
+    stringio (3.1.7)
+    thor (1.4.0)
+    tsort (0.2.0)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (3.2.0)
+      unicode-emoji (~> 4.1)
+    unicode-emoji (4.1.0)
+    uri (1.0.4)
+    zeitwerk (2.7.3)
+
+PLATFORMS
+  aarch64-linux-gnu
+  aarch64-linux-musl
+  arm-linux-gnu
+  arm-linux-musl
+  arm64-darwin
+  x86-linux-gnu
+  x86-linux-musl
+  x86_64-darwin
+  x86_64-linux-gnu
+  x86_64-linux-musl
+
+DEPENDENCIES
+  irb
+  minitest (~> 5.16)
+  plugin-gem-example!
+  rake (~> 13.0)
+  rubocop (~> 1.21)
+
+BUNDLED WITH
+   2.6.8

data/dsl/plugin-gem-example/lib/other.rb

@@ -0,0 +1,17 @@
+# typed: true
+# frozen_string_literal: true
+
+module MyCogNamespace
+  class Other < Roast::DSL::Cog
+    class Input < Roast::DSL::Cog::Input
+      def validate!
+        true
+      end
+    end
+
+    #: (Input) -> void
+    def execute(input)
+      puts "I'm a different cog!"
+    end
+  end
+end

data/dsl/plugin-gem-example/lib/plugin_gem_example.rb

@@ -0,0 +1,5 @@
+# typed: false
+# frozen_string_literal: true
+
+require "simple"
+require "other"

data/dsl/plugin-gem-example/lib/simple.rb

@@ -0,0 +1,15 @@
+# typed: true
+# frozen_string_literal: true
+
+class Simple < Roast::DSL::Cog
+  class Input < Roast::DSL::Cog::Input
+    def validate!
+      true
+    end
+  end
+
+  #: (Input) -> void
+  def execute(input)
+    puts "I'm a cog!"
+  end
+end

data/dsl/plugin-gem-example/lib/version.rb

@@ -0,0 +1,10 @@
+# typed: false
+# frozen_string_literal: true
+
+module Plugin
+  module Gem
+    module Example
+      VERSION = "0.1.0"
+    end
+  end
+end

data/dsl/plugin-gem-example/plugin-gem-example.gemspec

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "lib/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "plugin-gem-example"
+  spec.version = Plugin::Gem::Example::VERSION
+  spec.authors = ["Sam Schmidt"]
+  spec.email = ["sam.schmidt@shopify.com"]
+
+  spec.summary = "TODO: Write a short summary, because RubyGems requires one."
+  spec.description = "TODO: Write a longer description or delete this line."
+  spec.homepage = "TODO: Put your gem's website or public repo URL here."
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.1.0"
+
+  spec.metadata["allowed_push_host"] = "TODO: Set to your gem server 'https://example.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "TODO: Put your gem's public repo URL here."
+  spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Uncomment to register a new dependency of your gem
+  spec.add_dependency("roast-ai")
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/dsl/prompts/simple_prompt.md.erb

@@ -0,0 +1,3 @@
+You just told me the following about a lake. Make some stuff up about why that's nonsense.
+
+<%= lake_answer %>

data/dsl/prototype.rb

@@ -1,17 +1,23 @@
 # typed: true
 # frozen_string_literal: true
 
-#: self as Roast::DSL::Executor
+#: self as Roast::DSL::Workflow
 
 config do
-  cmd(:echo) { print_all! }
+  cmd(:echo) { display! }
+  cmd(/date/) { display! }
 end
 
 execute do
   # Anonymous cog. Added to the stack directly and given an autogenerated key in cog storage
   # Use for actions you do once and forget about, don't need configuration
-  cmd { "touch tmp/#{SecureRandom.uuid} " }
+  cmd { |my| my.command = "touch tmp/#{SecureRandom.uuid}" }
 
   # Named cog. Configuration for this specific instance will be looked up from config block
-  cmd(:echo) { "echo 'Hello World!'" }
+  cmd(:echo) { |my| my.command = "echo 'Hello World!'" }
+
+  # Cogs can implement input coercion for simple return values
+  fmt = "\"+%a %b %d %T %Z %Y\""
+  cmd(:date_today) { "/bin/date #{fmt}" }
+  cmd(:date_yesterday) { RUBY_PLATFORM.include?("darwin") ? "/bin/date -jv -1d #{fmt}" : "/bin/date -d '-1 day' #{fmt}" }
 end

data/dsl/repeat_loop_results.rb

@@ -0,0 +1,53 @@
+# typed: true
+# frozen_string_literal: true
+
+#: self as Roast::DSL::Workflow
+
+config do
+end
+
+execute do
+  repeat(:loop, run: :loop_body) { 7 }
+
+  ruby do
+    # You can access the final output value of a `repeat` cog directly
+    result = repeat!(:loop)
+    puts "Ultimate Loop Result: #{result.value}"
+  end
+
+  ruby do
+    puts "---"
+    # You can also access the final result, or individual cog results, of any specific iteration
+    # In the same manner as you would use `from` to access the results of a single `call` invocation.
+    puts "First Iteration Result: #{from(repeat!(:loop).first)}"
+    puts "Final Iteration Result: #{from(repeat!(:loop).last)}"
+    puts "Second-to-last Iteration Result: #{from(repeat!(:loop).iteration(-2))}"
+    # NOTE: accessing a specific iteration will raise an IndexException if the requested index is out of bounds
+    # for the number of iterations that ran.
+  end
+
+  ruby do
+    puts "---"
+    # You can access the results of all iterations in the same manner as you would use `collect` or `reduce`
+    # to access the complete results of a `map` invocation.
+    puts "All :add cog outputs: #{collect(repeat!(:loop).results) { ruby!(:add).value }}"
+    puts "Sum of :add cog output: #{reduce(repeat!(:loop).results, 0) { |acc| acc + ruby!(:add).value }}"
+  end
+end
+
+execute(:loop_body) do
+  # on each loop iteration, the input value provided will be the output value of the previous iteration
+  # the initial value will be what was provided when `repeat` was called in the outer scope.
+  ruby(:add) do |_, num, idx|
+    new_num = num + idx
+    s = "iteration #{idx}: #{num} + #{idx} -> #{new_num}"
+    puts s
+    new_num
+  end
+
+  ruby { |_, _, idx| break! if idx >= 3 }
+
+  # The value provided to `outputs` will be the input value for the next iteration
+  # On the final iteration, it will also be the `repeat` cog's own output value
+  outputs { ruby!(:add).value }
+end

data/dsl/ruby_cog.rb

@@ -0,0 +1,72 @@
+# typed: true
+# frozen_string_literal: true
+
+#: self as Roast::DSL::Workflow
+
+class MyClass
+  class << self
+    def add_stuff(a, b)
+      a + b
+    end
+  end
+end
+
+config do
+  cmd { display! }
+end
+
+execute do
+  cmd(:roast) { "echo Roast" }
+
+  # The `ruby` cog just passes the return value from its input block directly to its output.
+  # Letting you write whatever ruby code you want to generate that output
+  ruby(:whatever) do
+    # Do whatever you want in this block
+    value = cmd!(:roast).text
+    puts "Hello, #{value.upcase}"
+    puts "Calling a method: #{MyClass.add_stuff(3, 4)}"
+    # The value you return will be exposed as the .value attribute on the cog's output
+    1..5
+  end
+
+  cmd(:numbers) do |my|
+    my.command = "echo"
+    value = ruby!(:whatever).value.map { |n| n.to_s * n }
+    my.args = value
+  end
+
+  ruby(:advanced_hash_output) do
+    {
+      some_number: 7,
+      some_string: "Hello, world!",
+      multiply: proc { |a, b| a * b },
+    }
+  end
+
+  ruby do
+    result = ruby!(:advanced_hash_output) #: untyped
+
+    # If the output's `value` is a Hash, you can access its items directly from the output object
+    puts "Some Number + 1: #{result[:some_number] + 1}"
+    # You can also access its items as getter methods on the output object
+    puts "Some String to Upper: #{result.some_string.upcase}"
+    # And, if one of those items is a proc, you can call it directly on the output object
+    puts "Multiply 4 * 3: #{result.multiply(4, 3)}"
+  end
+
+  ruby(:advanced_object_output) do |my|
+    my.value = <<~STRING
+      This is a long block of test
+      Consisting of many lines
+      Three, to be precise
+    STRING
+  end
+
+  ruby do
+    result = ruby!(:advanced_object_output) #: untyped
+
+    # You can also call methods on the output's `value` directly, regardless of its type
+    puts "The long string has #{result.lines.length} lines"
+    puts "And it has #{result.length} characters"
+  end
+end

data/dsl/simple_agent.rb

@@ -0,0 +1,18 @@
+# typed: true
+# frozen_string_literal: true
+
+#: self as Roast::DSL::Workflow
+
+config do
+  agent do
+    provider :claude
+    model "haiku"
+    initial_prompt "Always respond in haiku form"
+    show_prompt!
+    dump_raw_agent_messages_to "tmp/claude-messages.log"
+  end
+end
+
+execute do
+  agent { "What is the world's largest lake?" }
+end

data/dsl/simple_chat.rb

@@ -0,0 +1,26 @@
+# typed: true
+# frozen_string_literal: true
+
+#: self as Roast::DSL::Workflow
+
+config do
+  chat(:lake) { model("gpt-4o") }
+  chat(:next) { model("gpt-4o-mini") }
+end
+
+execute do
+  # Ask a question
+  chat(:lake) { "What is the deepest lake?" }
+
+  # Continue the conversation (with a different model!)
+  chat(:next) do |my|
+    my.prompt = "What answer did you just give, and why?"
+    my.session = chat!(:lake).session
+  end
+
+  # Ask a question with a template prompt. You can pass variables to it as you would an ERB template
+  chat { template("dsl/prompts/simple_prompt.md.erb", { lake_answer: chat!(:lake).response }) }
+
+  # Shorthand to look up a template prompt
+  # chat { template("simple_prompt", { lake_answer: chat!(:lake).response }) }
+end