agent_c 2.71828

data/lib/agent_c/prompts.yml

@@ -0,0 +1,53 @@
+en:
+  agent:
+    chat:
+      refine:
+        system_message: |
+          ---BEGIN-SYSTEM-MESSAGE---
+          Hello, this conversation is currently being "refined". That means,
+          this prompt was already asked to an AI and an answer was received.
+
+          The user is requesting that you "refine" the answer given by the
+          prior AI conversation. Your goal is to review the prior answer,
+          evaluate its accuracy. If you determine that some changes should be
+          made, then adjust the answer and respond with the corrected version.
+          It is possible that the prior answer is accurate and acceptable. In
+          that case, simply respond with the prior answer as-is.
+
+          Here is the answer previously given to this prompt:
+
+          ---BEGIN-PRIOR-ANSWER---
+          %{prior_answer}
+          ---END-PRIOR-ANSWER---
+          ---END-SYSTEM-MESSAGE---
+
+          %{original_message}
+      get_result:
+        json_instructions: |
+          Your response will be parsed as JSON directly by passing it to JSON.parse.
+
+          DO NOT add any commentary to the JSON response.
+          DO NOT format your response as markdown
+          DO NOT begin your response with "```" OR "```json"
+
+          YOUR RESPONSE SHOULD BE PURE JSON AND BEGIN WITH ONE OF THE FOLLOWING: {["
+        schema_requirement: |
+          Your answer to the following request must be JSON that adheres to
+          the following schema.
+
+          ---BEGIN-JSON-SCHEMA---
+          %{json_schema}
+          ---END-JSON-SCHEMA---
+        request_wrapper: |
+          ---BEGIN-REQUEST---
+          %{msg}
+          ---END-REQUEST---
+        schema_validation_error: |
+          Your response did not adhere to the given schema. Its errors:
+          %{errors}
+        json_parse_error: |
+          Your response failed to parse as JSON. RESPOND WITH ONLY VALID JSON
+          NOTHING ELSE.
+  task_1:
+    pending: |
+      Translate the word "%{word}" to %{language}.

data/lib/agent_c/schema.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "ruby_llm/schema"
+
+module AgentC
+  module Schema
+    class AnyOneOf
+      attr_reader :schemas
+      def initialize(*schemas)
+        @schemas = schemas
+      end
+
+      def to_nested_schema
+        to_json_schema.fetch(:schema).fetch(:oneOf)
+      end
+
+      def schema_jsons
+        @schema_jsons ||= (
+          schemas.flat_map do |schema|
+            if schema.is_a?(AnyOneOf)
+              to_nested_schema
+            elsif schema.is_a?(Hash)
+              schema
+            elsif schema.ancestors.include?(RubyLLM::Schema)
+              schema.new.to_json_schema.fetch(:schema)
+            else
+              raise ArgumentError, "Invalid schema class: #{schema}"
+            end
+          end
+        )
+      end
+
+      def to_json_schema
+        {
+          schema: {
+            oneOf: schema_jsons
+          }
+        }
+      end
+    end
+
+    class ErrorSchema < RubyLLM::Schema
+      string(
+        :status,
+        enum: ["error"],
+      )
+
+      string(
+        :message,
+        description: <<~TXT
+          A brief description of the reason you could not fulfill the request.
+        TXT
+      )
+    end
+
+    def self.result(schema: nil, &)
+      # Create the success schema
+      success_schema = (
+        if schema.nil?
+          Class.new(RubyLLM::Schema) do
+            string(
+              :status,
+              enum: ["success"],
+            )
+
+            instance_exec(&) if block_given?
+          end
+        elsif schema.respond_to?(:call)
+          Class.new(RubyLLM::Schema) do
+            string(
+              :status,
+              enum: ["success"],
+            )
+
+            instance_exec(&schema)
+          end
+        else
+          schema
+        end
+      )
+
+      AnyOneOf.new(success_schema, ErrorSchema)
+    end
+  end
+end

data/lib/agent_c/session.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module AgentC
+  class Session
+    Configuration = Data.define(
+      :agent_db_path,
+      :logger,
+      :i18n_path,
+      :workspace_dir,
+      :project,
+      :run_id,
+      :max_spend_project,
+      :max_spend_run,
+      :extra_tools,
+    )
+
+    attr_reader :logger
+
+    def initialize(
+      agent_db_path:,
+      project:,
+      logger: Logger.new("/dev/null"),
+      workspace_dir: Dir.pwd,
+      run_id: Time.now.to_i,
+      i18n_path: nil,
+      max_spend_project: nil,
+      max_spend_run: nil,
+      ruby_llm: {},
+      extra_tools: {},
+      chat_provider: ->(**params) { create_chat(**params) }
+    )
+      @agent_db_path = agent_db_path
+      @project = project
+      @logger = logger
+      @workspace_dir = workspace_dir
+      @run_id = run_id
+      @i18n_path = i18n_path
+      @max_spend_project = max_spend_project
+      @max_spend_run = max_spend_run
+      @ruby_llm = ruby_llm
+
+      unless extra_tools.is_a?(Hash)
+        raise ArgumentError, "extra_tools must be a hash mapping name to class or instance"
+      end
+      @extra_tools = extra_tools
+
+      @chat_provider = chat_provider
+
+      unless agent_db_path.match(/.sqlite3?$/)
+        raise ArgumentError, "agent_db_path must end with '.sqlite3' or '.sqlite'"
+      end
+
+      # Load i18n path if provided
+      if i18n_path
+        I18n.load_path << i18n_path
+      end
+    end
+
+    def chat(
+      tools: Tools::NAMES.keys,
+      cached_prompts: [],
+      workspace_dir: nil,
+      record: nil
+    )
+      @chat_provider.call(
+        tools: tools,
+        cached_prompts: cached_prompts,
+        workspace_dir: workspace_dir || config.workspace_dir,
+        record: record,
+        session: self
+      )
+    end
+
+    def prompt(
+      tool_args: {},
+      tools: Tools::NAMES.keys + config.extra_tools.keys,
+      cached_prompt: [],
+      prompt:,
+      schema:,
+      on_chat_created: ->(*) {}
+    )
+      workspace_dir = tool_args[:workspace_dir] || config.workspace_dir
+
+      resolved_tools = (
+        tools
+          .map { |value|
+            Tools.resolve(
+              value:,
+              available_tools: Tools::NAMES.merge(config.extra_tools),
+              args: tool_args,
+              workspace_dir: config.workspace_dir
+            )
+          }
+      )
+
+      chat_instance = chat(
+        tools: resolved_tools,
+        cached_prompts: cached_prompt,
+        workspace_dir: workspace_dir
+      )
+      on_chat_created.call(chat_instance.id)
+
+      message = Array(prompt).join("\n")
+
+      begin
+        result = chat_instance.get(message, schema: Schema.result(&schema))
+
+        Agent::ChatResponse.new(
+          chat_id: chat_instance.id,
+          raw_response: result,
+        )
+      rescue => e
+        Agent::ChatResponse.new(
+          chat_id: chat_instance.id,
+          raw_response: {
+            "status" => "error",
+            "message" => ["#{e.class.name}:#{e.message}", e.backtrace].join("\n")
+          },
+        )
+      end
+    end
+
+    def config
+      @config ||= Configuration.new(
+        agent_db_path: @agent_db_path,
+        logger: @logger,
+        i18n_path: @i18n_path,
+        workspace_dir: @workspace_dir,
+        project: @project,
+        run_id: @run_id,
+        max_spend_project: @max_spend_project,
+        max_spend_run: @max_spend_run,
+        extra_tools: @extra_tools,
+      )
+    end
+
+    def ruby_llm_context
+      @ruby_llm_context ||= RubyLLM.context do |ctx_config|
+        @ruby_llm.each do |key, value|
+          ctx_config.public_send("#{key}=", value)
+        end
+        ctx_config.use_new_acts_as = true
+      end
+    end
+
+    def agent_store
+      @agent_store ||= Db::Store.new(
+        path: @agent_db_path,
+        logger: @logger,
+        versioned: false
+      )
+    end
+
+    def cost
+      Costs::Data.calculate(
+        agent_store: agent_store,
+        project: config.project,
+        run_id: config.run_id
+      )
+    end
+
+    private
+
+    def create_chat(**params)
+      real_record = params[:record] || (
+        Agent::Chats::AnthropicBedrock.create(
+          project: config.project,
+          run_id: config.run_id,
+          prompts: params.fetch(:cached_prompts, []),
+          agent_store:,
+          ruby_llm_context:
+        )
+      )
+
+      real_record.on_end_message do |message|
+        check_abort_cost
+      end
+
+      Agent::Chat.new(
+        **params.except(:record),
+        record: real_record
+      )
+    end
+
+    def check_abort_cost
+      return unless config.max_spend_project || config.max_spend_run
+
+      if config.max_spend_project && cost.project >= config.max_spend_project
+        raise Errors::AbortCostExceeded.new(
+          cost_type: "project",
+          current_cost: cost.project,
+          threshold: config.max_spend_project
+        )
+      end
+
+      if config.max_spend_run && cost.run >= config.max_spend_run
+        raise Errors::AbortCostExceeded.new(
+          cost_type: "run",
+          current_cost: cost.run,
+          threshold: config.max_spend_run
+        )
+      end
+    end
+  end
+end

data/lib/agent_c/store.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module AgentC
+  module Store
+    extend ActiveSupport::Concern
+
+    included do
+      record(:workspace) do
+        schema do |t|
+          t.string(:dir, null: false)
+          t.json(:env, default: [])
+        end
+
+        def self.ensure_created!(dir:, env:)
+          find_or_create_by!(dir:).tap { _1.update!(env:) }
+        end
+      end
+
+      record(:task) do
+        schema do |t|
+          t.string(:status, default: "pending")
+          t.json(:completed_steps, default: [])
+          t.string(:record_type)
+          t.integer(:record_id)
+          t.references(:workspace)
+
+          t.string(:handler)
+
+          t.string(:error_message)
+          t.json(:chat_ids, default: [])
+
+          t.timestamps
+        end
+
+        belongs_to(
+          :record,
+          polymorphic: true,
+          required: false
+        )
+
+        belongs_to(
+          :workspace,
+          class_name: class_name(:workspace),
+          required: false
+        )
+
+        def fail!(message)
+          update!(
+            status: "failed",
+            error_message: message
+          )
+        end
+
+        def done!
+          update!(status: "done")
+        end
+
+        def done?
+          status == "done"
+        end
+
+        def failed?
+          status == "failed"
+        end
+
+        def pending?
+          status == "pending"
+        end
+      end
+    end
+  end
+end

data/lib/agent_c/test_helpers.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require "ostruct"
+require "json-schema"
+require "tmpdir"
+
+module AgentC
+  module TestHelpers
+    # Helper to create a test session with minimal required parameters
+    def test_session(
+      agent_db_path: File.join(Dir.mktmpdir, "db.sqlite"),
+      **overrides
+    )
+      Session.new(
+        agent_db_path:,
+        project: "test_project",
+        **overrides
+      )
+    end
+
+    # DummyChat that maps input_text => output_text for testing
+    # Use this with Session.new() by passing it as a chat_provider or record parameter
+    class DummyChat
+      attr_reader :id, :messages_history, :tools_received, :prompts_received, :invocations
+
+      def initialize(
+        responses: {},
+        prompts: [],
+        tools: [],
+        cached_prompts: [],
+        workspace_dir: nil,
+        record: nil,
+        session: nil,
+        **_options
+      )
+        @responses = responses
+        @id = "test-chat-#{rand(1000)}"
+        @messages_history = []
+        @prompts_received = prompts
+        @tools_received = tools
+        @on_end_message_blocks = []
+      end
+
+      def ask(input_text)
+        # Try to find a matching response
+        _, output = (
+          @responses.find do |key, value|
+            (key.is_a?(Regexp) && input_text.match?(key)) ||
+              (key.is_a?(Proc) && key.call(input_text)) ||
+              (key == input_text)
+          end
+        )
+
+        output_text = (
+          if output.respond_to?(:call)
+            output.call
+          else
+            output
+          end
+        )
+
+        raise "No response configured for: #{input_text.inspect}" if output_text.nil?
+
+        # Create a mock message with the input
+        user_message = OpenStruct.new(
+          role: :user,
+          content: input_text,
+          to_llm: OpenStruct.new(to_h: { role: :user, content: input_text })
+        )
+
+        # Create a mock response message
+        response_message = OpenStruct.new(
+          role: :assistant,
+          content: output_text,
+          to_llm: OpenStruct.new(to_h: { role: :assistant, content: output_text })
+        )
+
+        @messages_history << user_message
+        @messages_history << response_message
+
+        # Call all on_end_message hooks
+        @on_end_message_blocks.each { |block| block.call(response_message) }
+
+        response_message
+      end
+
+      def get(input_text, schema: nil, **options)
+        # Similar to ask, but returns parsed JSON as a Hash for structured responses
+        response_message = ask(input_text)
+
+        json_schema = schema&.to_json_schema&.fetch(:schema)
+
+        # Parse the response content as JSON
+        begin
+          result = JSON.parse(response_message.content)
+          if json_schema.nil? || JSON::Validator.validate(json_schema, result)
+            result
+          else
+            raise "Failed to get valid response"
+          end
+        rescue JSON::ParserError
+          # If not valid JSON, wrap in a hash
+          { "result" => response_message.content }
+        end
+      end
+
+      def messages(...)
+        @messages_history
+      end
+
+      def with_tools(*tools)
+        @tools_received = tools.flatten
+        self
+      end
+
+      def on_new_message(&block)
+        self
+      end
+
+      def on_end_message(&block)
+        @on_end_message_blocks << block
+        self
+      end
+
+      def on_tool_call(&block)
+        self
+      end
+
+      def on_tool_result(&block)
+        self
+      end
+    end
+
+    # DummyGit for testing git operations without actual git commands
+    # Use this by passing it as the git parameter to Pipeline.call
+    class DummyGit
+      attr_reader :invocations
+
+      def initialize(workspace_dir)
+        @workspace_dir = workspace_dir
+        @invocations = []
+      end
+
+      def uncommitted_changes?
+        @has_changes ||= false
+      end
+
+      def commit_all(message)
+        @invocations << {
+          method: :commit_all,
+          args: [message],
+          params: {}
+        }
+      end
+
+      def simulate_file_created!
+        @has_changes = true
+      end
+
+      def method_missing(method, *args, **params)
+        @invocations << {
+          method:,
+          args:,
+          params:,
+        }
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        true
+      end
+    end
+  end
+end

data/lib/agent_c/tools/dir_glob.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module AgentC
+  module Tools
+    class DirGlob < RubyLLM::Tool
+      description("Find files in a directory using a ruby-compatible glob pattern.")
+
+      params do
+        string(
+          :glob_pattern,
+          description: "Only returns children paths of the current directory"
+        )
+      end
+
+      attr_reader :workspace_dir
+      def initialize(workspace_dir: nil, **)
+        raise ArgumentError, "workspace_dir is required" unless workspace_dir
+        @workspace_dir = workspace_dir
+      end
+
+      def execute(glob_pattern:, **params)
+        if params.any?
+          return "The following params were passed but are not allowed: #{params.keys.join(",")}"
+        end
+
+        unless Paths.allowed?(workspace_dir, glob_pattern)
+          return "Path: #{glob_pattern} not acceptable. Must be a child of directory: #{workspace_dir}."
+        end
+
+        results = (
+          Dir
+            .glob(File.join(workspace_dir, glob_pattern))
+            .select { Paths.allowed?(workspace_dir, _1) }
+        )
+
+        warning = (
+          if results.count > 30
+            "Returning 30 of #{results.count} results"
+          end
+        )
+
+        [warning, results.take(30).to_json].compact.join("\n")
+      end
+    end
+  end
+end