agent_c 2.9979 → 2.71828

data/docs/testing.md

@@ -98,9 +98,9 @@ def test_agent_step_inline
   # Match the LITERAL prompt strings with %{placeholders}, not interpolated values
   dummy_chat = DummyChat.new(responses: {
     "Summarize the document titled %{title}" =>
-      '{" "summary": "A comprehensive report"}',
+      '{"status": "success", "summary": "A comprehensive report"}',
     "Categorize this document: %{summary}" =>
-      '{" "category": "Research"}'
+      '{"status": "success", "category": "Research"}'
   })
 
   session = test_session(
@@ -133,8 +133,8 @@ def test_i18n_agent_step
   # I18n interpolates BEFORE sending to DummyChat
   # DummyChat receives: "Process file report.pdf" (interpolated!)
   dummy_chat = DummyChat.new(responses: {
-    "Process file report.pdf" => '{}',  # ✓ Correct
-    "Process file %{file_name}" => '{}' # ✗ Wrong - won't match
+    "Process file report.pdf" => '{"status": "success"}',  # ✓ Correct
+    "Process file %{file_name}" => '{"status": "success"}' # ✗ Wrong - won't match
   })
 
   session = test_session(
@@ -185,7 +185,7 @@ def test_agent_step_with_i18n
   # Configure DummyChat with matching response
   dummy_chat = DummyChat.new(responses: {
     "Summarize the document titled 'My Document' in category 'Technical'" =>
-      '{" "summary": "This is a technical document about programming."}'
+      '{"status": "success", "summary": "This is a technical document about programming."}'
   })
 
   # Create session with DummyChat
@@ -231,7 +231,7 @@ def test_agent_step_with_regex_matching
 
   # Use regex to match prompts flexibly
   dummy_chat = DummyChat.new(responses: {
-    /Process document:/ => '{" "category": "Processed"}'
+    /Process document:/ => '{"status": "success", "category": "Processed"}'
   })
 
   session = test_session(
@@ -270,7 +270,7 @@ def test_agent_step_failure
   })
 
   dummy_chat = DummyChat.new(responses: {
-    "This will fail" => '{"unable_to_fulfill_request_error": "Processing failed"}'
+    "This will fail" => '{"status": "error", "message": "Processing failed"}'
   })
 
   session = test_session(
@@ -332,11 +332,11 @@ def test_multi_step_pipeline
   # Configure responses for each step
   dummy_chat = DummyChat.new(responses: {
     "Extract title" =>
-      '{" "title": "Research Paper"}',
+      '{"status": "success", "title": "Research Paper"}',
     "Summarize document: Research Paper" =>
-      '{" "summary": "A study on testing"}',
+      '{"status": "success", "summary": "A study on testing"}',
     /Categorize: Research Paper - A study on testing/ =>
-      '{" "category": "Research"}'
+      '{"status": "success", "category": "Research"}'
   })
 
   session = test_session(
@@ -444,7 +444,7 @@ session = Session.new(
   chat_provider: ->(**params) {
     DummyChat.new(
       responses: {
-        "What is 2+2?" => '{" "answer": "4"}'
+        "What is 2+2?" => '{"status": "success", "answer": "4"}'
       },
       **params
     )
@@ -493,7 +493,7 @@ session = Session.new(
   chat_provider: ->(**params) {
     DummyChat.new(
       responses: {
-        "What is Ruby?" => '{" "answer": "A programming language"}'
+        "What is Ruby?" => '{"status": "success", "answer": "A programming language"}'
       },
       **params
     )
@@ -508,7 +508,7 @@ session = Session.new(
   chat_provider: ->(**params) {
     DummyChat.new(
       responses: {
-        /extract.*email/ => '{" "email": "user@example.com"}'
+        /extract.*email/ => '{"status": "success", "email": "user@example.com"}'
       },
       **params
     )
@@ -529,7 +529,7 @@ session = Session.new(
   chat_provider: ->(**params) {
     DummyChat.new(
       responses: {
-        ->(text) { text.include?("hello") } => '{" "greeting": "Hi!"}'
+        ->(text) { text.include?("hello") } => '{"status": "success", "greeting": "Hi!"}'
       },
       **params
     )
@@ -559,7 +559,7 @@ session = Session.new(
       responses: {
         "Write file" => -> {
           File.write("/tmp/test.txt", "content")
-          '{" "path": "/tmp/test.txt"}'
+          '{"status": "success", "path": "/tmp/test.txt"}'
         }
       },
       **params
@@ -607,7 +607,7 @@ session = Session.new(
   chat_provider: ->(**params) {
     DummyChat.new(
       responses: {
-        "Process data" => '{" "result": "processed"}'
+        "Process data" => '{"status": "success", "result": "processed"}'
       },
       **params
     )
@@ -630,7 +630,7 @@ session = Session.new(
   chat_provider: ->(**params) {
     DummyChat.new(
       responses: {
-        "Impossible task" => '{"unable_to_fulfill_request_error": "Cannot complete"}'
+        "Impossible task" => '{"status": "error", "message": "Cannot complete"}'
       },
       **params
     )
@@ -659,7 +659,7 @@ class MyFeatureTest < Minitest::Test
       chat_provider: ->(**params) {
         DummyChat.new(
           responses: {
-            /extract.*email/ => '{" "email": "john@example.com"}'
+            /extract.*email/ => '{"status": "success", "email": "john@example.com"}'
           },
           **params
         )
@@ -680,7 +680,7 @@ class MyFeatureTest < Minitest::Test
       chat_provider: ->(**params) {
         DummyChat.new(
           responses: {
-            "Invalid input" => '{"unable_to_fulfill_request_error": "Input validation failed"}'
+            "Invalid input" => '{"status": "error", "message": "Input validation failed"}'
           },
           **params
         )

data/lib/agent_c/agent/chat_response.rb

@@ -11,27 +11,21 @@ module AgentC
     end
 
     def success?
-      !@raw_response.key?("unable_to_fulfill_request_error")
+      status == "success"
     end
 
     def status
-      if success?
-        "success"
-      else
-        "error"
-      end
+      @raw_response.fetch("status")
     end
 
     def data
       raise "Cannot call data on failed response. Use error_message instead." unless success?
-
-      raw_response
+      raw_response.reject { |k, _| k == "status" }
     end
 
     def error_message
       raise "Cannot call error_message on successful response. Use data instead." if success?
-
-      raw_response.fetch("unable_to_fulfill_request_error")
+      raw_response.fetch("message")
     end
     end
   end

data/lib/agent_c/batch.rb

@@ -23,8 +23,8 @@ module AgentC
       @git = git
     end
 
-    def call(&)
-      processor.call(&)
+    def call
+      processor.call
     end
 
     def add_task(record)
@@ -43,50 +43,14 @@ module AgentC
       pending_count = tasks.count { |task| task.pending? }
       failed_count = tasks.count { |task| task.failed? }
 
-      out.puts "Total: #{tasks.count}"
       out.puts "Succeeded: #{succeeded_count}"
       out.puts "Pending: #{pending_count}"
       out.puts "Failed: #{failed_count}"
 
-      # Calculate time span
-      if tasks.any?
-        created_ats = tasks.map(&:created_at).compact
-        updated_ats = tasks.map(&:updated_at).compact
-
-        if created_ats.any? && updated_ats.any?
-          earliest = created_ats.min
-          latest = updated_ats.max
-          time_span_seconds = (latest - earliest).to_i
-
-          hours = time_span_seconds / 3600
-          minutes = (time_span_seconds % 3600) / 60
-          seconds = time_span_seconds % 60
-
-          out.puts "Time: #{hours} hrs, #{minutes} mins, #{seconds} secs"
-        end
-      end
-
-      # Count worktrees
-      worktree_count = store.workspace.count
-      out.puts "Worktrees: #{worktree_count}"
-
       cost_data = session.cost
       out.puts "Run cost: $#{'%.2f' % cost_data.run}"
       out.puts "Project total cost: $#{'%.2f' % cost_data.project}"
 
-      # Cost and time per task
-      if tasks.count > 0
-        cost_per_task = cost_data.run / tasks.count.to_f
-        out.puts "Cost per task: $#{'%.2f' % cost_per_task}"
-
-        if tasks.any? && created_ats&.any? && updated_ats&.any?
-          total_minutes = time_span_seconds / 60.0
-
-          minutes_per_task = total_minutes * worktree_count / tasks.count
-          out.puts "Minutes per task: #{'%.2f' % minutes_per_task}"
-        end
-      end
-
       if failed_count > 0
         out.puts "\nFirst #{[failed_count, 3].min} failed task(s):"
         tasks.select { |task| task.failed? }.first(3).each do |task|
@@ -101,8 +65,8 @@ module AgentC
       context.store
     end
 
-    def workspaces
-      context.workspaces
+    def workspace
+      context.workspace
     end
 
     def session

data/lib/agent_c/configs/repo.rb

@@ -42,7 +42,7 @@ module AgentC
           else
             logger.info("creating/resetting worktree at: #{worktree_dir}")
             git.create_worktree(
-              worktree_dir: worktree_dir,
+              dir: worktree_dir,
               branch: spec.fetch(:branch),
               revision: initial_revision,
             )

data/lib/agent_c/pipeline.rb

@@ -36,19 +36,84 @@ module AgentC
         self.steps << Step.new(name:, block:)
       end
 
-      def agent_review_loop(name, **params)
+      def agent_step(name, **params, &block)
         step(name) do
-          agent = Pipelines::Agent.new(self)
-          agent.agent_review_loop(name, **params)
-        end
-      end
+          resolved_params = (
+            if block
+              instance_exec(&block)
+            elsif params.empty?
+              i18n_attributes = (
+                if record.respond_to?(:i18n_attributes)
+                  record.i18n_attributes
+                else
+                  record.attributes
+                end
+              )
+
+              {
+                tool_args: {
+                  workspace_dir: workspace.dir,
+                  env: workspace.env,
+                },
+                cached_prompt: I18n.t("#{name}.cached_prompts"),
+                prompt: I18n.t("#{name}.prompt", **i18n_attributes.symbolize_keys),
+                tools: I18n.t("#{name}.tools"),
+                schema: -> {
+                  next unless I18n.exists?("#{name}.response_schema")
+
+                  I18n.t("#{name}.response_schema").each do |name, spec|
+                    extra = spec.except(:required, :description, :type)
+
+                    if extra.key?(:of)
+                      extra[:of] = extra[:of]&.to_sym
+                    end
+
+                    send(
+                      spec.fetch(:type, "string"),
+                      name,
+                      required: spec.fetch(:required, true),
+                      description: spec.fetch(:description),
+                      **extra
+                    )
+                  end
+                }
+              }
+            else
+              i18n_attributes = (
+                if record.respond_to?(:i18n_attributes)
+                  record.i18n_attributes
+                else
+                  record.attributes
+                end
+              )
+
+              {
+                tool_args: {
+                  workspace_dir: workspace.dir,
+                  env: workspace.env,
+                }
+              }.tap { |hash|
+                if params.key?(:prompt_key)
+                  hash[:prompt] = I18n.t(params[:prompt_key],  **i18n_attributes.symbolize_keys)
+                end
+
+                if params.key?(:cached_prompt_keys)
+                  hash[:cached_prompt] = params[:cached_prompt_keys].map { I18n.t(_1) }
+                end
+              }.merge(params.except(:cached_prompt_keys, :prompt_key))
+            end
+          )
 
-      def agent_step(name, **params, &block)
-        raise ArgumentError.new("Can't pass block and params") if params.any? && block
+          result = session.prompt(
+            on_chat_created: -> (id) { task.chat_ids << id},
+            **resolved_params
+          )
 
-        step(name) do
-          agent = Pipelines::Agent.new(self)
-          agent.agent_step(name, **params, &block)
+          if result.success?
+            task.record.update!(result.data)
+          else
+            task.fail!(result.error_message)
+          end
         end
       end
     end
@@ -58,17 +123,18 @@ module AgentC
 
       log("start")
 
-      while(task.pending?)
+      self.class.steps.each do |step|
         break if task.failed?
 
-        step = self.class.steps.find { !task.completed_steps.include?(_1.name.to_s) }
-        break if step.nil?
-
-        @rewind_to = nil
 
         store.transaction do
           log_prefix = "step: '#{step.name}'"
 
+          if task.completed_steps.include?(step.name.to_s)
+            log("#{log_prefix} already completed, skipping")
+            next
+          end
+
           log("#{log_prefix} start")
 
           instance_exec(&step.block)
@@ -76,31 +142,6 @@ module AgentC
           if task.failed?
             log("#{log_prefix} failed, executing on_failures")
             self.class.on_failures.each { instance_exec(&_1)}
-          elsif @rewind_to
-            matching_steps = task.completed_steps.select { _1 == @rewind_to }
-
-            if matching_steps.count == 0
-              raise ArgumentError, <<~TXT
-                Cannot rewind to a step that's not been completed yet:
-
-                rewind_to!(#{@rewind_to.inspect})
-                completed_steps: #{task.completed_steps.inspect}
-              TXT
-            elsif matching_steps.count > 1
-              raise ArgumentError, <<~TXT
-                Cannot rewind to a step with a non-distinct name. The step
-                name appears multiple times:
-
-                rewind_to!(#{@rewind_to.inspect})
-                completed_steps: #{task.completed_steps.inspect}
-              TXT
-            end
-
-            log("#{log_prefix} rewind_to! #{@rewind_to.inspect}")
-            task
-              .completed_steps
-              .index(@rewind_to)
-              .then { task.update!(completed_steps: task.completed_steps[0..._1]) }
           else
             log("#{log_prefix} done")
             task.completed_steps << step.name.to_s
@@ -132,12 +173,8 @@ module AgentC
       task.store
     end
 
-    def rewind_to!(step)
-      @rewind_to = step.to_s
-    end
-
-    def git
-      @_git ||= @git.call(workspace.dir)
+    def repo
+      @repo ||= @git.call(workspace.dir)
     end
 
     def log(msg)
@@ -147,6 +184,5 @@ module AgentC
     def logger
       session.logger
     end
-
   end
 end

data/lib/agent_c/processor.rb

@@ -66,7 +66,7 @@ module AgentC
     def call_synchronous(workspace)
       while(handler = next_handler(workspace))
         handler.call
-        yield(handler.task) if block_given? # allow the invoker to do work inbetween handler calls
+        yield if block_given? # allow the invoker to do work inbetween handler calls
       end
     end
 

data/lib/agent_c/schema.rb

@@ -41,13 +41,14 @@ module AgentC
 
     class ErrorSchema < RubyLLM::Schema
       string(
-        :unable_to_fulfill_request_error,
-        description: <<~TXT
-          Only fill out this field if you are unable to perform the requested
-          task and/or unable to fulfill the other schema provided.
+        :status,
+        enum: ["error"],
+      )
 
-          Fill this in a clear message indicating why you were unable to fulfill
-          the request.
+      string(
+        :message,
+        description: <<~TXT
+          A brief description of the reason you could not fulfill the request.
         TXT
       )
     end
@@ -55,10 +56,23 @@ module AgentC
     def self.result(schema: nil, &)
       # Create the success schema
       success_schema = (
-        if block_given? || schema&.respond_to?(:call)
+        if schema.nil?
           Class.new(RubyLLM::Schema) do
+            string(
+              :status,
+              enum: ["success"],
+            )
+
             instance_exec(&) if block_given?
-            instance_exec(&schema) if schema
+          end
+        elsif schema.respond_to?(:call)
+          Class.new(RubyLLM::Schema) do
+            string(
+              :status,
+              enum: ["success"],
+            )
+
+            instance_exec(&schema)
           end
         else
           schema

data/lib/agent_c/session.rb

@@ -115,7 +115,8 @@ module AgentC
         Agent::ChatResponse.new(
           chat_id: chat_instance.id,
           raw_response: {
-            "unable_to_fulfill_request_error" => ["#{e.class.name}:#{e.message}", e.backtrace].join("\n")
+            "status" => "error",
+            "message" => ["#{e.class.name}:#{e.message}", e.backtrace].join("\n")
           },
         )
       end

data/lib/agent_c/tools/edit_file.rb

@@ -14,7 +14,7 @@ module AgentC
         string(
           :mode,
           description: "Operation mode: 'overwrite' (replace entire file), 'replace_lines' (replace line range), 'insert_at_line' (insert before specified line), 'append' (add to end)",
-          enum: ["overwrite", "replace_lines", "insert_at_line", "append", "delete"],
+          enum: ["overwrite", "replace_lines", "insert_at_line", "append"],
           required: true
         )
         string(
@@ -55,8 +55,6 @@ module AgentC
         workspace_path = Paths.relative_to_dir(workspace_dir, path)
 
         case mode
-        when "delete"
-          FileUtils.rm_f(path)
         when "overwrite"
           FileUtils.mkdir_p(File.dirname(workspace_path))
           File.write(workspace_path, content)

data/lib/agent_c/tools.rb

@@ -9,7 +9,6 @@ module AgentC
       file_metadata: FileMetadata,
       dir_glob: DirGlob,
       run_rails_test: RunRailsTest,
-      git_status: GitStatus
     }
 
     def self.all(**params)

data/lib/agent_c/utils/git.rb

@@ -6,62 +6,50 @@ module AgentC
   module Utils
     # Git utility class for managing Git operations in worktrees
     class Git
-      attr_reader :dir
+      attr_reader :repo_path
 
-      def initialize(dir)
-        @dir = dir
+      def initialize(repo_path)
+        @repo_path = repo_path
       end
 
-      def create_worktree(worktree_dir:, branch:, revision:)
+      def create_worktree(dir:, branch:, revision:)
         # Prune any stale worktrees first
-        shell.run!("cd #{dir} && git worktree prune")
+        shell.run!("cd #{repo_path} && 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!("cd #{repo_path} && (git worktree remove #{Shellwords.escape(dir)} --force 2>/dev/null || true)")
 
         shell.run!(
           <<~TXT
-            cd #{dir} && \
+            cd #{repo_path} && \
               git worktree add \
                 -B #{Shellwords.escape(branch)} \
-                #{Shellwords.escape(worktree_dir)} \
+                #{Shellwords.escape(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
-        )
+        shell.run!("cd #{repo_path} && git diff")
       end
 
       def last_revision
-        shell.run!("cd #{dir} && git rev-parse @").strip
+        shell.run!("cd #{repo_path} && 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)}")
+        shell.run!("cd #{repo_path} && 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}")
+        shell.run!("cd #{repo_path} && 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")
+        shell.run!("cd #{repo_path} && git add --all && git reset --hard")
       end
 
       def clean?
@@ -71,7 +59,7 @@ module AgentC
       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 = shell.run!("cd #{repo_path} && git status --porcelain")
         !status.strip.empty?
       end
 

data/lib/agent_c/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: agent_c
 version: !ruby/object:Gem::Version
-  version: '2.9979'
+  version: '2.71828'
 platform: ruby
 authors:
 - Pete Kinnecom
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-09 00:00:00.000000000 Z
+date: 2026-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zeitwerk
@@ -108,7 +108,6 @@ files:
 - Rakefile
 - TODO.md
 - agent_c.gemspec
-- docs/batch.md
 - docs/chat-methods.md
 - docs/cost-reporting.md
 - docs/pipeline-tips-and-tricks.md
@@ -128,7 +127,6 @@ files:
 - lib/agent_c/db/store.rb
 - lib/agent_c/errors.rb
 - lib/agent_c/pipeline.rb
-- lib/agent_c/pipelines/agent.rb
 - lib/agent_c/processor.rb
 - lib/agent_c/prompts.yml
 - lib/agent_c/schema.rb
@@ -139,7 +137,6 @@ files:
 - lib/agent_c/tools/dir_glob.rb
 - lib/agent_c/tools/edit_file.rb
 - lib/agent_c/tools/file_metadata.rb
-- lib/agent_c/tools/git_status.rb
 - lib/agent_c/tools/grep.rb
 - lib/agent_c/tools/paths.rb
 - lib/agent_c/tools/read_file.rb