agent_c 2.9

data/lib/agent_c/tools/run_rails_test.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "shellwords"
+
+module AgentC
+  module Tools
+    class RunRailsTest < RubyLLM::Tool
+      description "Runs a minitest rails test using bin/rails test {path} --name={name_of_test_method}"
+
+      params do
+        string(
+          :path,
+          description: "Path to file. Must be a child of current directory.",
+          required: true
+        )
+        string(
+          :test_method_name,
+          description: "The name of the specific test method to run",
+          required: false
+        )
+        boolean(
+          :disable_spring,
+          description: <<~TXT,
+            Disable spring if the errors are weird and you want to make sure
+            it's not a spring issue. Prefer to use spring unless you are
+            encountering weird behavior.
+          TXT
+          required: false
+        )
+      end
+
+      attr_reader :workspace_dir, :env
+      def initialize(
+        workspace_dir: nil,
+        env: {},
+        **
+      )
+        raise ArgumentError, "workspace_dir is required" unless workspace_dir
+        @env = env
+        @workspace_dir = workspace_dir
+      end
+
+      def execute(path:, test_method_name: nil, disable_spring: false, **params)
+
+        # Spring hangs, need to timeout unresponsive shells
+        disable_spring = true
+
+        if params.any?
+          return "The following params were passed but are not allowed: #{params.keys.join(",")}"
+        end
+
+        unless Paths.allowed?(workspace_dir, path)
+          return "Path: #{path} not acceptable. Must be a child of directory: #{workspace_dir}."
+        end
+
+        workspace_path = Paths.relative_to_dir(workspace_dir, path)
+
+        env_string = env.is_a?(Hash) ? env.map { |k, v| "#{k}=#{Shellwords.escape(v)}"}.join(" ") : env
+
+        env_string += " DISABLE_SPRING=1" if disable_spring
+
+        cmd = <<~TXT.chomp
+          cd #{workspace_dir} && \
+          #{env_string} bundle exec rails test #{path} #{test_method_name && "--name='#{test_method_name}'"}
+        TXT
+
+        lines = []
+        result = nil
+        Bundler.with_unbundled_env do
+          result = shell.run(cmd) do |stream, line|
+            lines << "[#{stream}] #{line}"
+          end
+        end
+
+        return <<~TXT
+          Command exited #{result.success? ? "successfully" : "with non-zero exit code"}
+          ---
+          #{lines.join("\n")}
+        TXT
+      end
+
+      def shell
+        AgentC::Utils::Shell
+      end
+    end
+  end
+end

data/lib/agent_c/tools.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module AgentC
+  module Tools
+    NAMES = {
+      read_file: ReadFile,
+      edit_file: EditFile,
+      grep: Grep,
+      file_metadata: FileMetadata,
+      dir_glob: DirGlob,
+      run_rails_test: RunRailsTest,
+      git_status: GitStatus
+    }
+
+    def self.all(**params)
+      NAMES.values.map { _1.new(**params) }
+    end
+
+    def self.resolve(value:, available_tools:, args:, workspace_dir:)
+
+      # ensure any args passed have a
+      # workspace_dir.
+      resolved_args = (
+        if args.key?(:workspace_dir)
+          args
+        else
+          args.merge(workspace_dir:)
+        end
+      )
+
+      # If they passed a tool instance, nothing to do
+      if value.is_a?(RubyLLM::Tool)
+        return value
+      elsif value.is_a?(Symbol) || value.is_a?(String)
+        # They passed the tool name
+        # we must initialize it with
+        # the standard args
+        tool_name = value.to_sym
+        unless available_tools.key?(tool_name)
+          raise ArgumentError, <<~TXT
+            Unknown tool name: #{value.inspect}.
+            If you wish to use a custom tool you must configure
+            it by passing `extra_tools` to the Session.
+          TXT
+        end
+
+        klass_or_instance = available_tools.fetch(tool_name)
+
+        if klass_or_instance.is_a?(RubyLLM::Tool)
+          klass_or_instance
+        else
+          klass_or_instance.new(**resolved_args)
+        end
+      elsif value.is_a?(Class) && value.ancestors.include?(RubyLLM::Tool)
+        value.new(**resolved_args)
+      else
+        raise ArgumentError, "unknown tool specified: #{value.inspect}"
+      end
+    end
+  end
+end

data/lib/agent_c/utils/git.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "shellwords"
+
+module AgentC
+  module Utils
+    # Git utility class for managing Git operations in worktrees
+    class Git
+      attr_reader :dir
+
+      def initialize(dir)
+        @dir = dir
+      end
+
+      def create_worktree(worktree_dir:, branch:, revision:)
+        # Prune any stale worktrees first
+        shell.run!("cd #{dir} && git worktree prune")
+
+        # Remove worktree at dir if it exists (don't fail if it doesn't exist)
+        shell.run!("cd #{dir} && (git worktree remove #{Shellwords.escape(worktree_dir)} --force 2>/dev/null || true)")
+
+        shell.run!(
+          <<~TXT
+            cd #{dir} && \
+              git worktree add \
+                -B #{Shellwords.escape(branch)} \
+                #{Shellwords.escape(worktree_dir)} \
+                #{Shellwords.escape(revision)}
+          TXT
+        )
+      end
+
+      def diff
+        # --intent-to-add will ensure untracked files are included
+        # in the diff.
+        shell.run!(
+          <<~TXT
+            cd #{dir} && \
+            git add --all --intent-to-add && \
+            git diff --relative
+          TXT
+        )
+      end
+
+      def last_revision
+        shell.run!("cd #{dir} && git rev-parse @").strip
+      end
+
+      def commit_all(message)
+        shell.run!("cd #{dir} && git add --all && git commit --no-gpg-sign -m #{Shellwords.escape(message)}")
+        last_revision
+      end
+
+      def fixup_commit(revision)
+        shell.run!("cd #{dir} && git add --all && git commit --no-gpg-sign --fixup #{revision}")
+        last_revision
+      end
+
+      def reset_hard_all
+        shell.run!("cd #{dir} && git add --all && git reset --hard")
+      end
+
+      def status
+        shell.run!("cd #{dir} && git status")
+      end
+
+      def clean?
+        !uncommitted_changes?
+      end
+
+      def uncommitted_changes?
+        # Check for any changes including untracked files
+        # Returns true if there are uncommitted changes (staged, unstaged, or untracked)
+        status = shell.run!("cd #{dir} && git status --porcelain")
+        !status.strip.empty?
+      end
+
+      private
+
+      def shell
+        AgentC::Utils::Shell
+      end
+    end
+
+    # TODO: Add more utility classes here as needed
+  end
+end

data/lib/agent_c/utils/shell.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require "open3"
+
+module AgentC
+  module Utils
+    class Shell
+      Error = Class.new(StandardError)
+      class << self
+        Result = Struct.new(:command, :success, :stdout, :stderr, keyword_init: true) do
+          def success?
+            success
+          end
+        end
+
+        def run!(...)
+          # only returns stdout just because.
+          run(...)
+            .tap { raise "command failed: \n#{_1.inspect}" unless _1.success? }
+            .stdout
+        end
+
+        def run(command)
+          Open3.popen3(command) do |_in, stdout, stderr, wait_thr|
+            process_stdout = []
+            stdout_thr = Thread.new do
+              while line = stdout.gets&.chomp
+                yield(:stdout, line) if block_given?
+                process_stdout << line
+              end
+            end
+
+            process_stderr = []
+            stderr_thr = Thread.new do
+              while line = stderr.gets&.chomp
+                yield(:stderr, line) if block_given?
+                process_stderr << line
+              end
+            end
+
+            [
+              stderr_thr,
+              stdout_thr,
+            ].each(&:join)
+
+            Result.new(
+              command: command,
+              success: wait_thr.value.success?,
+              stdout: process_stdout.join("\n"),
+              stderr: process_stderr.join("\n"),
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/agent_c/version.rb

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

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