agent_c 2.9

data/lib/versioned_store/stores/schema.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "set"
+module VersionedStore
+  module Stores
+    class Schema
+      Record = Data.define(:name, :table, :blocks)
+      Migration = Data.define(:version, :block)
+
+      class RecordContext
+        attr_reader :schema_instance, :table_name, :record_name
+
+        def initialize(schema_instance, record_name)
+          @schema_instance = schema_instance
+          @record_name = record_name
+          @table_name = nil
+        end
+
+        def schema(table_name = nil, &block)
+          # If no table name provided, infer from record name
+          if table_name.nil?
+            name_str = record_name.to_s
+            table_name = (name_str.end_with?('s') ? name_str : "#{name_str}s").to_sym
+          end
+
+          # Store the table name for later use
+          @table_name = table_name
+
+          # Collect all schema blocks for a table
+          schema_instance.schema_blocks[table_name] ||= []
+          schema_instance.schema_blocks[table_name] << block if block
+        end
+
+        def method_missing(...)
+        end
+
+        def respond_to_missing?(...)
+          true
+        end
+      end
+
+      attr_reader :migrations, :records, :migrated_tables, :schema_blocks, :post_init_hooks
+      def initialize
+        @migrations = []
+        @records = {}
+        @migration_counter = 1
+        @migrated_tables = Set.new
+        @schema_blocks = {}
+        @post_init_hooks = []
+      end
+
+      def dup
+        new_schema = Schema.new
+        new_schema.instance_variable_set(:@migrations, @migrations.dup)
+        new_schema.instance_variable_set(:@records, @records.dup)
+        new_schema.instance_variable_set(:@migration_counter, @migration_counter)
+        new_schema.instance_variable_set(:@migrated_tables, @migrated_tables.dup)
+        new_schema.instance_variable_set(:@schema_blocks, @schema_blocks.dup)
+        new_schema.instance_variable_set(:@post_init_hooks, @post_init_hooks.dup)
+        new_schema.instance_variable_set(:@dir, @dir)
+        new_schema
+      end
+
+      def dir(path = nil)
+        @dir = path if path
+        @dir
+      end
+
+      def migrate(version = @migration_counter += 1, &block)
+        migrations << Migration.new(version: version, block: block)
+      end
+
+      def prepend_migration(version, &block)
+        migrations.unshift(Migration.new(version: version, block: block))
+      end
+
+      def record(name, table: nil, &block)
+        # If block is given, execute it in RecordContext to extract schema calls
+        extracted_table = table
+        if block
+          context = RecordContext.new(self, name)
+          context.instance_exec(&block)
+          extracted_table ||= context.table_name
+        end
+
+        prev = records[name]
+        blocks = prev ? prev.blocks.dup : []
+        blocks << block if block
+        # Prefer the first non-nil table name, otherwise default to name + "s"
+        table_name = prev&.table || extracted_table
+        if table_name.nil?
+          name_str = name.to_s
+          table_name = (name_str.end_with?('s') ? name_str : "#{name_str}s").to_sym
+        end
+
+        records[name] = Record.new(
+          name: name,
+          table: table_name,
+          blocks: blocks
+        )
+      end
+
+      # Add a migration for each table with collected schema blocks (called after all record blocks)
+      def add_table_migrations!
+        schema_blocks.each do |table_name, blocks|
+          next if migrated_tables.include?(table_name) || table_name.nil?
+          blocks_to_eval = blocks.dup
+          migration_block = Proc.new do
+            create_table(table_name) do |t|
+              blocks_to_eval.each { |blk| blk.call(t) }
+            end
+          end
+          version = "table_#{table_name}"
+          prepend_migration(version, &migration_block)
+          migrated_tables.add(table_name)
+        end
+      end
+
+      def self.call(&block)
+        schema = new
+        schema.instance_exec(&block) if block
+        schema.add_table_migrations!
+        schema
+      end
+    end
+  end
+end

data/lib/versioned_store/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module VersionedStore
+  VERSION = "0.1.0"
+end

data/lib/versioned_store.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module VersionedStore
+  class Error < StandardError; end
+end

data/template/Gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gem "agent_c", path: "../../agent_c"
+
+gem "rake"
+gem "minitest"
+gem "debug"

data/template/Gemfile.lock

@@ -0,0 +1,152 @@
+PATH
+  remote: ..
+  specs:
+    agent_c (2.71828)
+      activerecord
+      async
+      json-schema
+      ruby_llm
+      sqlite3
+      zeitwerk
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (8.1.2)
+      activesupport (= 8.1.2)
+    activerecord (8.1.2)
+      activemodel (= 8.1.2)
+      activesupport (= 8.1.2)
+      timeout (>= 0.4.0)
+    activesupport (8.1.2)
+      base64
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.3.1)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      json
+      logger (>= 1.4.2)
+      minitest (>= 5.1)
+      securerandom (>= 0.3)
+      tzinfo (~> 2.0, >= 2.0.5)
+      uri (>= 0.13.1)
+    addressable (2.8.8)
+      public_suffix (>= 2.0.2, < 8.0)
+    async (2.36.0)
+      console (~> 1.29)
+      fiber-annotation
+      io-event (~> 1.11)
+      metrics (~> 0.12)
+      traces (~> 0.18)
+    base64 (0.3.0)
+    bigdecimal (4.0.1)
+    concurrent-ruby (1.3.6)
+    connection_pool (3.0.2)
+    console (1.34.2)
+      fiber-annotation
+      fiber-local (~> 1.1)
+      json
+    date (3.5.1)
+    debug (1.11.1)
+      irb (~> 1.10)
+      reline (>= 0.3.8)
+    drb (2.2.3)
+    erb (6.0.1)
+    event_stream_parser (1.0.0)
+    faraday (2.14.0)
+      faraday-net_http (>= 2.0, < 3.5)
+      json
+      logger
+    faraday-multipart (1.2.0)
+      multipart-post (~> 2.0)
+    faraday-net_http (3.4.2)
+      net-http (~> 0.5)
+    faraday-retry (2.4.0)
+      faraday (~> 2.0)
+    fiber-annotation (0.2.0)
+    fiber-local (1.1.0)
+      fiber-storage
+    fiber-storage (1.0.1)
+    i18n (1.14.8)
+      concurrent-ruby (~> 1.0)
+    io-console (0.8.2)
+    io-event (1.14.2)
+    irb (1.16.0)
+      pp (>= 0.6.0)
+      rdoc (>= 4.0.0)
+      reline (>= 0.4.2)
+    json (2.18.0)
+    json-schema (6.1.0)
+      addressable (~> 2.8)
+      bigdecimal (>= 3.1, < 5)
+    logger (1.7.0)
+    marcel (1.1.0)
+    metrics (0.15.0)
+    minitest (6.0.1)
+      prism (~> 1.5)
+    multipart-post (2.4.1)
+    net-http (0.9.1)
+      uri (>= 0.11.1)
+    pp (0.6.3)
+      prettyprint
+    prettyprint (0.2.0)
+    prism (1.8.0)
+    psych (5.3.1)
+      date
+      stringio
+    public_suffix (7.0.2)
+    rake (13.3.1)
+    rdoc (7.1.0)
+      erb
+      psych (>= 4.0.0)
+      tsort
+    reline (0.6.3)
+      io-console (~> 0.5)
+    ruby_llm (1.11.0)
+      base64
+      event_stream_parser (~> 1)
+      faraday (>= 1.10.0)
+      faraday-multipart (>= 1)
+      faraday-net_http (>= 1)
+      faraday-retry (>= 1)
+      marcel (~> 1.0)
+      ruby_llm-schema (~> 0.2.1)
+      zeitwerk (~> 2)
+    ruby_llm-schema (0.2.5)
+    securerandom (0.4.1)
+    sqlite3 (2.9.0-aarch64-linux-gnu)
+    sqlite3 (2.9.0-aarch64-linux-musl)
+    sqlite3 (2.9.0-arm-linux-gnu)
+    sqlite3 (2.9.0-arm-linux-musl)
+    sqlite3 (2.9.0-arm64-darwin)
+    sqlite3 (2.9.0-x86_64-darwin)
+    sqlite3 (2.9.0-x86_64-linux-gnu)
+    sqlite3 (2.9.0-x86_64-linux-musl)
+    stringio (3.2.0)
+    timeout (0.6.0)
+    traces (0.18.2)
+    tsort (0.2.0)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    uri (1.1.1)
+    zeitwerk (2.7.4)
+
+PLATFORMS
+  aarch64-linux-gnu
+  aarch64-linux-musl
+  arm-linux-gnu
+  arm-linux-musl
+  arm64-darwin
+  x86_64-darwin
+  x86_64-linux-gnu
+  x86_64-linux-musl
+
+DEPENDENCIES
+  agent_c!
+  debug
+  minitest
+  rake
+
+BUNDLED WITH
+   2.6.5

data/template/README.md

@@ -0,0 +1,61 @@
+# Overview
+
+This directory contains a small script demonstrating how to run a batch of pipelines.
+
+For each `summary` record created, Claude will choose a random file, summarize it, and write the summary to disk. Then our pipeline commits the changes at the end.
+
+It creates two records and runs them across two worktrees.
+
+The main entrypoint is the Rakefile.
+
+
+### Running the Batch
+
+You'll need to set the relevant environment variables specified in the Config. (The environment variables necessary assume you're using Claude on Bedrock.)
+
+Then run:
+
+```sh
+bin/rake run
+# => Summary report:
+# => Succeeded: 2
+# => Pending: 0
+# => Failed: 0
+# => Run cost: $0.31
+# => Project total cost: $1.67
+# => ---
+# => task: 1 - wrote summary to /tmp/example-worktrees/summary-examples-0/VERSIONED_STORE_BASE_SUMMARY.md
+# => task: 2 - wrote summary to /tmp/example-worktrees/summary-examples-1/SUMMARY-es.md
+```
+
+### Watching progress
+
+You can tail the logs with:
+
+```sh
+# See EVERYTHING
+tail -f log/run.log
+
+# See just progress
+tail -f log/run.log | grep INFO
+```
+
+### Poking around the data
+
+```sh
+bin/rake console
+```
+
+### Resetting state
+
+Delete the state stored in the `./tmp` directory to start all over:
+
+```sh
+rm -rf ./tmp
+```
+
+### Run the tests:
+
+```sh
+bin/rake test
+```

data/template/Rakefile

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "rake/testtask"
+
+require_relative "./lib/autoload"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
+  t.warning = false
+end
+
+desc "Run the pipeline"
+task :run do
+  batch = AgentC::Batch.new(**Config::BATCH)
+
+  ["english", "spanish"].map do |language|
+    record = batch.store.summary.find_or_create_by!(language:)
+
+    batch.add_task(record)
+  end
+
+  batch.call
+
+  puts "Summary report:"
+  puts batch.report
+  puts "---\n"
+
+  batch.store.task.all.each do |task|
+    next unless task.done?
+
+    full_path = File.join(
+      task.workspace.dir,
+      task.record.summary_path
+    )
+    puts "task: #{task.id} - wrote summary to #{full_path}"
+  end
+end
+
+task :console do
+  batch = AgentC::Batch.new(**Config::BATCH)
+
+  # poke around the data here
+  binding.irb
+end
+
+task default: :test

data/template/bin/rake

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
+
+bundle_binstub = File.expand_path("bundle", __dir__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300).include?("This file was generated by Bundler")
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rake", "rake")

data/template/lib/autoload.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "versioned_store"
+require "agent_c"
+require "i18n"
+require "zeitwerk"
+
+loader = Zeitwerk::Loader.new
+loader.push_dir(File.expand_path(__dir__))
+loader.setup

data/template/lib/config.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "tmpdir"
+
+module Config
+  LOG_PATH = "./log/run.log"
+  FileUtils.mkdir_p(File.dirname(LOG_PATH))
+
+  LOGGER = Logger.new(LOG_PATH)
+
+  PROJECT = "TemplateProject.v1"
+
+  BATCH = {
+    record_type: :summary,
+    pipeline: Pipeline,
+
+    store: {
+      class: Store,
+      config: {
+        logger: LOGGER,
+        dir: File.join(
+          File.expand_path("../tmp", __dir__),
+          PROJECT,
+        )
+      },
+    },
+
+    repo: {
+      dir: File.expand_path("../../", __dir__),
+      initial_revision: "main",
+      working_subdir: "", # use the root-level of the repo
+      worktrees_root_dir: "/tmp/example-worktrees",
+      worktree_branch_prefix: "summary-examples",
+      worktree_envs: [
+        {
+          SOME_ENV: "1",
+        },
+        {
+          SOME_ENV: "2",
+        },
+      ],
+    },
+
+    session: {
+      agent_db_path: File.expand_path("../../tmp/claude.sqlite", __dir__),
+      logger: LOGGER,
+      i18n_path: File.expand_path("prompts.yml", __dir__),
+      project: PROJECT,
+      ruby_llm: {
+        bedrock_api_key: ENV.fetch("AWS_ACCESS_KEY_ID"),
+        bedrock_secret_key: ENV.fetch("AWS_SECRET_ACCESS_KEY"),
+        bedrock_session_token: ENV.fetch("AWS_SESSION_TOKEN"),
+        bedrock_region: ENV.fetch("AWS_REGION", "us-west-2"),
+        default_model: ENV.fetch("LLM_MODEL", "us.anthropic.claude-sonnet-4-5-20250929-v1:0")
+      }
+    },
+  }
+end

data/template/lib/pipeline.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class Pipeline < AgentC::Pipeline
+  agent_step(:pick_a_random_file)
+  agent_step(:summarize_the_file)
+  agent_step(:write_summary_to_disk)
+
+  step(:finalize) do
+    if repo.uncommitted_changes?
+      repo.commit_all(
+        <<~TXT
+          claude: added file: #{record.summary_path}
+        TXT
+      )
+    else
+      task.fail!("didn't create a file")
+    end
+  end
+end

data/template/lib/prompts.yml

@@ -0,0 +1,57 @@
+en:
+  # This prompt will be used by all steps, it will be cached
+  # to save $$$.
+  global_summary_cache: &global_summary_cache |
+    This project is a ruby gem. You will be summarizing a file using
+    the language specified.
+  pick_a_random_file:
+    tools: [read_file, grep, dir_glob]
+    cached_prompts:
+    - *global_summary_cache
+    prompt: |
+      # YOUR JOB
+
+      Find a random ruby file within the repository. Bonus points for picking
+      a file with many lines.
+    response_schema:
+      input_path:
+        description: |
+          The path to the file you have chosen
+
+  summarize_the_file:
+    tools: [read_file]
+    cached_prompts:
+    - *global_summary_cache
+    prompt: |
+      You will be given a file path. Your job is to summarize the file for a
+      developer to read and understand.
+
+      You must write your summary using the language provided.
+
+      language: %{language}
+      file path: %{input_path}
+    response_schema:
+      summary_body:
+        description: |
+          Your summary of the file
+
+  write_summary_to_disk:
+    tools: [edit_file]
+    cached_prompts:
+    - *global_summary_cache
+    prompt: |
+      You will be given a file path and some summary text. Write the text to the
+      a well-named file at the top-level of the repository. You will return the
+      path that you wrote.
+
+      IMPORTANT: you **must** invoke the edit_file tool to process this request.
+
+      summary:
+      ---BEGIN-SUMMARY---
+      %{summary_body}
+      ---END-SUMMARY---
+
+    response_schema:
+      summary_path:
+        description: |
+          The path to the file you wrote.

data/template/lib/store.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Store < VersionedStore::Base
+  include AgentC::Store
+
+  record(:summary) do
+    schema do |t|
+      # we'll input this data
+      t.string(:language)
+
+      # claude will generate this data
+      t.string(:input_path)
+      t.string(:summary_body)
+      t.string(:summary_path)
+    end
+  end
+end