agent_c 2.71828

data/lib/agent_c.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "ruby_llm"
+require "active_support/all"
+
+# this shows an annyoing warning
+begin
+  old_stderr = $stderr
+  $stderr = StringIO.new
+  require "async"
+  require "async/semaphore"
+  $stderr = old_stderr
+ensure
+end
+
+require "zeitwerk"
+loader = Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
+loader.setup
+
+# Configure i18n how I like it:
+
+require "i18n"
+MissingTranslation = Class.new(StandardError)
+I18n.singleton_class.prepend(Module.new do
+  def t(*a, **p)
+    super(*a, __force_exception_raising__: true, **p)
+  end
+end)
+I18n.exception_handler = ->(_, _, key, _) { raise MissingTranslation.new(key.inspect) }
+I18n.load_path << File.join(__dir__, "./agent_c/prompts.yml")
+
+module AgentC; end

data/lib/versioned_store/base.rb

@@ -0,0 +1,314 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+module VersionedStore
+  class Base
+    class << self
+      def inherited(subclass)
+        super
+        # If parent has a schema, duplicate it for the child
+        # Otherwise create a new empty schema
+        parent_schema = @schema
+        if parent_schema
+          subclass.instance_variable_set(:@schema, parent_schema.dup)
+        else
+          subclass.instance_variable_set(:@schema, Stores::Schema.new)
+        end
+      end
+
+      def schema
+        @schema ||= Stores::Schema.new
+      end
+
+      def record(name, table: nil, &block)
+        schema.record(name, table: table, &block)
+      end
+
+      def migrate(version = nil, &block)
+        if version.nil?
+          schema.migrate(&block)
+        else
+          schema.migrate(version, &block)
+        end
+      end
+    end
+
+    attr_reader :schema, :version, :config
+    def initialize(version: :root, **config)
+      @schema = self.class.schema
+      @schema.add_table_migrations!
+      @version = version
+      @config = Config.new(**config)
+      @klasses = {}
+
+      if File.exist?(@config.db_filename)
+        @config&.logger&.info("using existing store at: #{@config.db_filename}")
+      else
+        @config&.logger&.info("creating store at: #{@config.db_filename}")
+      end
+
+
+      # Define accessor methods for each record type
+      schema.records.each do |name, spec|
+        singleton_class.define_method(name) { class_for(spec) }
+      end
+
+      # eagerly construct classes
+      schema.records.each_value { class_for(_1) }
+
+      # Run post-initialization hooks for setting up associations
+      schema.post_init_hooks.each { |hook| hook.call(self) }
+    end
+
+    def transaction(&)
+      base_class.transaction(&)
+    end
+
+    def dir
+      @config.dir
+    end
+
+    def versions
+      return [self] unless root?
+
+      version_files = Dir.glob(File.join(versions_dir, "*.sqlite3")).sort
+      version_files.map do |file|
+        version_num = File.basename(file, ".sqlite3").to_i
+        self.class.new(version: version_num, **config.to_h)
+      end
+    end
+
+    def restore(name = nil)
+      if name
+        # Named snapshot restore
+        raise "Can only restore from root store" unless root?
+
+        snapshot_path = File.join(snapshots_dir, "#{name}.sqlite3")
+        raise "Snapshot '#{name}' does not exist" unless File.exist?(snapshot_path)
+
+        # Copy the snapshot to the main database
+        main_db = File.join(dir, config.db_filename)
+        FileUtils.cp(snapshot_path, main_db)
+
+        # Create a new version snapshot of the restored state
+        timestamp = Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond)
+        version_file = File.join(versions_dir, "#{timestamp}.sqlite3")
+        FileUtils.mkdir_p(File.dirname(version_file))
+        FileUtils.cp(main_db, version_file)
+
+        # Return a new root store for the restored state
+        self.class.new(version:, **config.to_h)
+      else
+        # Version-based restore (existing behavior)
+        raise "Can only restore from a version snapshot, not from root" if root?
+
+        # Copy the version database to the main database
+        main_db = File.join(dir, config.db_filename)
+        FileUtils.cp(db_path, main_db)
+
+        # Renumber versions: keep all versions up to and including this one,
+        # then create a new version snapshot for the restore
+        version_files = Dir.glob(File.join(versions_dir, "*.sqlite3")).sort
+        version_files.each do |file|
+          file_version = File.basename(file, ".sqlite3").to_i
+          if file_version > version
+            FileUtils.rm(file)
+          end
+        end
+
+        # Create a new version snapshot of the restored state
+        new_version_num = version + 1
+        version_file = File.join(versions_dir, "#{new_version_num}.sqlite3")
+        FileUtils.cp(main_db, version_file)
+
+        # Return a new root store for the restored state
+        self.class.new(version: :root, **config.to_h)
+      end
+    end
+
+    def snapshot(name)
+      raise "Can only create snapshots from root store" unless root?
+
+      # Create snapshots directory if it doesn't exist
+      FileUtils.mkdir_p(snapshots_dir)
+
+      # Copy current database to named snapshot
+      snapshot_path = File.join(snapshots_dir, "#{name}.sqlite3")
+      FileUtils.cp(db_path, snapshot_path)
+    end
+
+    private
+
+    def schema_root_mod_name
+      @schema_root_mod_name ||+ "SchemaRoot_#{schema.object_id}_#{object_id}"
+    end
+
+    def schema_root_mod
+      @schema_root_mod ||= (
+        if Base.const_defined?(schema_root_mod_name)
+          Base.const_get(schema_root_mod_name)
+        else
+          Module.new.tap { Base.const_set(schema_root_mod_name, _1) }
+        end
+      )
+    end
+
+    def base_class
+      @base_class ||= (
+        me = self
+        klass = Class.new(ActiveRecord::Base) do
+          define_singleton_method(:transaction_mutex) do
+            @transaction_mutex ||= Mutex.new
+          end
+
+          define_singleton_method(:class_name) do |name|
+            "#{me.send(:schema_root_mod)}::Record_#{name}"
+          end
+
+          define_singleton_method(:store) do
+            me
+          end
+
+          define_method(:store) do
+            self.class.store
+          end
+
+          define_singleton_method(:transaction) do |**options, &block|
+            # If already in a transaction, just call super without creating a backup
+            return super(**options, &block) if connection.transaction_open?
+
+            transaction_mutex.synchronize do
+              result = super(**options, &block)
+
+              if me.config.versioned
+                timestamp = Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond)
+                backup_path = File.join(me.send(:versions_dir), "#{timestamp}.sqlite3")
+                FileUtils.mkdir_p(File.dirname(backup_path))
+                FileUtils.cp(me.send(:db_path), backup_path)
+              end
+
+              result
+            end
+          end
+        end
+
+        # ActiveRecord doesn't let this be anonymous?
+        schema_root_mod.const_set(
+          "Base",
+          klass
+        )
+
+        klass.abstract_class = true
+        klass.establish_connection(
+          adapter: 'sqlite3',
+          database: db_path
+        )
+
+        # Configure SQLite to use DELETE journal mode instead of WAL
+        # This avoids creating -wal and -shm files
+        klass.connection.execute("PRAGMA journal_mode=DELETE")
+        klass.connection.execute("PRAGMA locking_mode=NORMAL")
+
+        # Only run migrations for the root store, not for version snapshots
+        if root? && schema.migrations.any?
+          # Ensure schema_migrations table exists
+          unless klass.connection.table_exists?(:schema_migrations)
+            klass.connection.create_table(:schema_migrations, id: false) do |t|
+              t.string :version, null: false
+            end
+            klass.connection.add_index(:schema_migrations, :version, unique: true)
+          end
+
+          # Run any migrations that haven't been run yet
+          schema.migrations.each do |migration|
+            version = migration.version.to_s
+
+            # Check if migration has already been run using quote method for SQL safety
+            existing = klass.connection.select_value(
+              "SELECT 1 FROM schema_migrations WHERE version = #{klass.connection.quote(version)} LIMIT 1"
+            )
+            next if existing
+
+            # Run the migration
+            klass.connection.instance_exec(&migration.block)
+
+            # Record that this migration has been run
+            klass.connection.execute(
+              "INSERT INTO schema_migrations (version) VALUES (#{klass.connection.quote(version)})"
+            )
+          end
+        end
+
+        klass
+      )
+    end
+
+    def class_for(spec)
+      @klasses[spec.name] ||= (
+        store = self
+        Class.new(base_class) do
+          self.table_name = spec.table
+
+          # Execute all blocks if present, but define a schema method to ignore schema calls
+          if spec.blocks && !spec.blocks.empty?
+            define_singleton_method(:schema) { |*args, &blk| }
+            spec.blocks.each do |blk|
+              class_exec(&blk) if blk
+            end
+            singleton_class.remove_method(:schema) rescue nil
+          end
+
+          # Make all records readonly if this is a version snapshot
+          if not store.send(:root?)
+            define_method(:readonly?) { true }
+          end
+
+          # Override polymorphic_name to return simple string name (both instance and class methods)
+          simple_name = spec.name.to_s
+
+          define_method(:polymorphic_name) do
+            simple_name
+          end
+
+          define_singleton_method(:polymorphic_name) do
+            simple_name
+          end
+
+          # Override polymorphic_class_for to resolve simple names back to classes
+          define_singleton_method(:polymorphic_class_for) do |name|
+            store.send(:class_for, store.schema.records.fetch(name.to_sym))
+          end
+        end
+      ).tap {
+        schema_root_mod.const_set("Record_#{spec.name}", _1)
+      }
+    end
+
+    def db_prefix
+      @db_prefix ||= config.db_filename.sub(/\.sqlite3$/, "")
+    end
+
+    def versions_dir
+      @versions_dir ||= File.join(dir, "#{db_prefix}_versions")
+    end
+
+    def snapshots_dir
+      @snapshots_dir ||= File.join(dir, "#{db_prefix}_snapshots")
+    end
+
+    def db_path
+      @db_path ||= (
+        if root?
+          File.join(dir, config.db_filename)
+        else
+          File.join(versions_dir, "#{version}.sqlite3")
+        end
+      )
+    end
+
+    def root?
+      version == :root
+    end
+  end
+end

data/lib/versioned_store/config.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module VersionedStore
+  Config = Data.define(:dir, :db_filename, :logger, :versioned) do
+    def initialize(dir: nil, path: nil, logger: nil, versioned: true, db_filename: nil)
+      raise ArgumentError, "Must provide either dir: or path:, not both" if dir && path
+      raise ArgumentError, "Must provide either dir: or path:" unless dir || path
+
+      db_filename ||= (
+        if path
+          dir = File.dirname(path)
+          db_filename = File.basename(path)
+        else
+          db_filename = "db.sqlite3"
+        end
+      )
+
+      super(
+        dir:,
+        db_filename:,
+        logger:,
+        versioned:
+      )
+    end
+  end
+end

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