agent_c 2.9

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

data/lib/agent_c/tools/edit_file.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module AgentC
+  module Tools
+    class EditFile < RubyLLM::Tool
+      description "Edits a file with various operations: overwrite entire file, replace specific lines, insert at position, or append"
+
+      params do
+        string(
+          :path,
+          description: "Path to file. Must be a child of current directory.",
+          required: true
+        )
+        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"],
+          required: true
+        )
+        string(
+          :content,
+          description: "The content to write, insert, or append. Can be multi-line.",
+          required: true
+        )
+        integer(
+          :start_line,
+          description: <<~TXT,
+            For replace_lines: first line to replace, inclusive (1-indexed).
+            For insert_at_line: line before which to insert (1=start of file, 999999=end of file).
+          TXT
+          required: false
+        )
+        integer(
+          :end_line,
+          description: "For replace_lines only: last line to replace, inclusive (1-indexed).",
+          required: false
+        )
+      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(path:, mode:, content:, start_line: nil, end_line: nil, **params)
+        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)
+
+        case mode
+        when "delete"
+          FileUtils.rm_f(path)
+        when "overwrite"
+          FileUtils.mkdir_p(File.dirname(workspace_path))
+          File.write(workspace_path, content)
+
+        when "replace_lines"
+          return "start_line and end_line required for replace_lines mode" unless start_line && end_line
+          return "start_line must be <= end_line" if start_line > end_line
+
+          lines = File.exist?(workspace_path) ? File.readlines(workspace_path, chomp: true) : []
+
+          # Convert to 0-indexed
+          start_idx = start_line - 1
+          end_idx = end_line - 1
+
+          # Replace the range with new content lines
+          new_lines = content.split("\n")
+          lines[start_idx..end_idx] = new_lines
+
+          File.write(workspace_path, lines.join("\n") + "\n")
+
+        when "insert_at_line"
+          return "start_line required for insert_at_line mode" unless start_line
+
+          lines = File.exist?(workspace_path) ? File.readlines(workspace_path, chomp: true) : []
+
+          # Insert before the specified line (1-indexed)
+          insert_idx = start_line - 1
+          insert_idx = [0, [insert_idx, lines.length].min].max  # Clamp to valid range
+
+          new_lines = content.split("\n")
+          lines.insert(insert_idx, *new_lines)
+
+          File.write(workspace_path, lines.join("\n") + "\n")
+
+        when "append"
+          FileUtils.mkdir_p(File.dirname(workspace_path))
+          File.open(workspace_path, "a") do |f|
+            f.write(content)
+            f.write("\n") unless content.end_with?("\n")
+          end
+        end
+
+        # Run syntax check for Ruby files
+        if workspace_path.end_with?(".rb")
+          syntax_check = `ruby -c #{workspace_path} 2>&1`
+          unless $?.success?
+            return "File successfully edited, but syntax errors were found:\n#{syntax_check}"
+          end
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/agent_c/tools/file_metadata.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module AgentC
+  module Tools
+    class FileMetadata < RubyLLM::Tool
+      description "Returns metadata of a file, including line-count, mtime"
+
+      params do
+        string(
+          :path,
+          description: "Path to file. Must be a child of 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(path:, line_range_start: 0, line_range_end: nil, **params)
+        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)
+
+        unless File.exist?(workspace_path)
+          return "File not found"
+        end
+
+        {
+          mtime: File.mtime(workspace_path),
+          lines: File.foreach(workspace_path).count,
+        }
+      end
+    end
+  end
+end

data/lib/agent_c/tools/git_status.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module AgentC
+  module Tools
+    class GitStatus < RubyLLM::Tool
+      description <<~DESC
+        Return the current git status
+      DESC
+
+      params do
+      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(**params)
+        if params.any?
+          return "The following params were passed but are not allowed: #{params.keys.join(",")}"
+        end
+
+        Utils::Git.new(workspace_dir).status
+      end
+    end
+  end
+end

data/lib/agent_c/tools/grep.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module AgentC
+  module Tools
+    class Grep < RubyLLM::Tool
+      description <<~DESC
+        Searches for patterns in files using git grep. Returns matching lines
+        with file paths and line numbers.
+      DESC
+
+      params do
+        string(
+          :pattern,
+          description: <<~DESC,
+            The regex pattern to search for. Use standard regex syntax.
+          DESC
+          required: true
+        )
+        string(
+          :file_pattern,
+          description: <<~DESC,
+            Optional glob pattern to limit search to specific files
+            (e.g., '*.rb', 'app/**/*.js'). If omitted, searches all files.
+          DESC
+          required: false
+        )
+        boolean(
+          :ignore_case,
+          description: <<~DESC,
+            If true, performs case-insensitive search. Default is false.
+          DESC
+          required: false
+        )
+        integer(
+          :context_lines,
+          description: <<~DESC,
+            Number of context lines to show before and after each match.
+            Default is 0.
+          DESC
+          required: false
+        )
+        integer(
+          :line_range_start,
+          description: <<~DESC,
+            Return results starting from this line number (1-indexed).
+            Default is 1.
+          DESC
+          required: false
+        )
+        integer(
+          :line_range_end,
+          description: <<~DESC,
+            Return results up to and including this line number (1-indexed).
+            If omitted, returns to the end.
+          DESC
+          required: false
+        )
+      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(pattern:, file_pattern: nil, ignore_case: false, context_lines: 0, line_range_start: 1, line_range_end: nil, **params)
+        if params.any?
+          return "The following params were passed but are not allowed: #{params.keys.join(",")}"
+        end
+
+        Dir.chdir(workspace_dir) do
+
+          cmd = ["git", "grep", "-n", "--extended-regexp"]  # -n shows line numbers
+
+          cmd << "-i" if ignore_case
+          cmd << "-C" << context_lines.to_s if context_lines > 0
+
+          cmd << "-e" << pattern
+
+          if file_pattern
+            cmd << "--" << file_pattern
+          end
+
+
+          stdout, stderr, status = Open3.capture3(*cmd)
+
+          if status.success?
+            lines = stdout.force_encoding("UTF-8").split("\n")
+
+            # Apply line range (convert to 0-indexed)
+            start_idx = [line_range_start - 1, 0].max
+            end_idx = line_range_end ? line_range_end - 1 : -1
+            lines = lines[start_idx..end_idx] || []
+
+            lines = lines.map { |l| l[0..100]}
+
+            total_lines = lines.length
+            max_lines = 300
+
+            if total_lines > max_lines
+              limited_content = lines[0...max_lines].join("\n")
+              return "Returning #{max_lines} lines out of #{total_lines} total lines:\n\n#{limited_content}"
+            else
+              return lines.join("\n")
+            end
+          elsif status.exitstatus == 1
+            # Exit status 1 means no matches found
+            return "No matches found."
+          else
+            # Other error
+            return "Error: #{stderr}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/agent_c/tools/paths.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module AgentC
+  module Tools
+    module Paths
+      module_function
+
+      def relative_to_dir(dir, path)
+        if path.start_with?(dir)
+          path
+        else
+          File.join(dir, path)
+        end
+      end
+
+      def allowed?(dir, path)
+        child?(dir, path)
+      end
+
+      def child?(parent_dir, child_path)
+
+        unless child_path.start_with?("/")
+          child_path = File.join(parent_dir, child_path)
+        end
+
+        child = Pathname.new(child_path).expand_path
+        parent = Pathname.new(parent_dir).expand_path
+
+        relative = child.relative_path_from(parent)
+        !relative.to_s.start_with?('..')
+      end
+    end
+  end
+end

data/lib/agent_c/tools/read_file.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+raise "here" if defined?(AgentC::Tools::ReadFile)
+
+module AgentC
+  module Tools
+    class ReadFile < RubyLLM::Tool
+      description "Reads the contents of a file"
+
+      params do
+        string(
+          :path,
+          description: <<~TXT
+            Path to file. Must be a child of current directory.
+
+            Only returns 300 lines at a time. Specify line range if possible
+            to avoid truncated responses.
+          TXT
+        )
+
+        number(
+          :line_range_start,
+          description: "Read lines on or after this line number.",
+          required: false
+        )
+
+        number(
+          :line_range_end,
+          description: "Read lines on or before this line number.",
+          required: false
+        )
+      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(path:, line_range_start: 0, line_range_end: nil, **params)
+        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)
+
+        unless File.exist?(workspace_path)
+          return "File not found"
+        end
+
+        all_lines = File.read(workspace_path).split("\n")
+        lines = all_lines[line_range_start..line_range_end]
+
+        total_lines = lines.length
+        max_lines = 300
+
+        # Determine the actual line range being returned (1-indexed for display)
+        actual_start = line_range_start + 1
+        actual_end = line_range_end ? [line_range_end + 1, all_lines.length].min : all_lines.length
+
+        if total_lines > max_lines
+          limited_content = format_with_line_numbers(lines[0...max_lines], actual_start)
+          limited_end = actual_start + max_lines - 1
+          "Returning lines #{actual_start}-#{limited_end}, out of #{total_lines} total lines:\n\n#{limited_content}"
+        elsif line_range_start > 0 || line_range_end
+          # Line range was specified
+          formatted_content = format_with_line_numbers(lines, actual_start)
+          "Returning lines #{actual_start}-#{actual_end}, out of #{all_lines.length} total lines:\n\n#{formatted_content}"
+        else
+          format_with_line_numbers(lines, 1)
+        end
+      rescue => e
+        "File read error: #{e.class}:#{e.message}"
+      end
+
+      private
+
+      # Format lines with line numbers
+      def format_with_line_numbers(lines, starting_line_num)
+        max_line_num = starting_line_num + lines.length - 1
+        width = max_line_num.to_s.length
+        lines.map.with_index do |line, idx|
+          line_num = starting_line_num + idx
+          "%#{width}d: %s" % [line_num, line]
+        end.join("\n")
+      end
+    end
+  end
+end