agent_c 2.71828

data/lib/agent_c/tools/edit_file.rb

@@ -0,0 +1,112 @@
+# 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"],
+          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 "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/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

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,60 @@
+# 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,
+    }
+
+    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,75 @@
+# frozen_string_literal: true
+
+require "shellwords"
+
+module AgentC
+  module Utils
+    # Git utility class for managing Git operations in worktrees
+    class Git
+      attr_reader :repo_path
+
+      def initialize(repo_path)
+        @repo_path = repo_path
+      end
+
+      def create_worktree(dir:, branch:, revision:)
+        # Prune any stale worktrees first
+        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 #{repo_path} && (git worktree remove #{Shellwords.escape(dir)} --force 2>/dev/null || true)")
+
+        shell.run!(
+          <<~TXT
+            cd #{repo_path} && \
+              git worktree add \
+                -B #{Shellwords.escape(branch)} \
+                #{Shellwords.escape(dir)} \
+                #{Shellwords.escape(revision)}
+          TXT
+        )
+      end
+
+      def diff
+        shell.run!("cd #{repo_path} && git diff")
+      end
+
+      def last_revision
+        shell.run!("cd #{repo_path} && git rev-parse @").strip
+      end
+
+      def commit_all(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 #{repo_path} && git add --all && git commit --no-gpg-sign --fixup #{revision}")
+        last_revision
+      end
+
+      def reset_hard_all
+        shell.run!("cd #{repo_path} && git add --all && git reset --hard")
+      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 #{repo_path} && 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.71828"
+end