rubyn 0.1.0

data/lib/rubyn/tools/find_references.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Rubyn
+  module Tools
+    class FindReferences < BaseTool
+      DESCRIPTION = "Find all references to a class, method, or constant across the project"
+      PARAMETERS = {
+        identifier: { type: "string", required: true, description: "The class, method, or constant name to find" },
+        type: { type: "string", required: false,
+                description: "Type of identifier: 'class', 'method', 'constant', or 'any' (default 'any')" }
+      }.freeze
+      REQUIRES_CONFIRMATION = false
+
+      MAX_RESULTS = 100
+
+      def execute(params)
+        identifier = params[:identifier]
+        return error("Missing required parameter: identifier") unless identifier
+
+        ref_type = params[:type] || "any"
+
+        regex = build_regex(identifier, ref_type)
+        return error("Invalid reference type: #{ref_type}") unless regex
+
+        references = []
+        rb_files = Dir.glob(File.join(project_root, "**", "*.rb"))
+
+        rb_files.each do |file|
+          break if references.size >= MAX_RESULTS
+          next if excluded?(file)
+
+          search_file_for_references(file, regex, references)
+        end
+
+        success(identifier: identifier, references: references)
+      end
+
+      private
+
+      def build_regex(identifier, type)
+        escaped = Regexp.escape(identifier)
+        case type
+        when "method"
+          Regexp.new("(?:\\.#{escaped}\\b|\\bdef\\s+#{escaped}\\b)")
+        when "class", "constant", "any"
+          Regexp.new("\\b#{escaped}\\b")
+        end
+      end
+
+      def search_file_for_references(file, regex, references)
+        File.open(file, "r:UTF-8") do |f|
+          f.each_line.with_index(1) do |line, line_number|
+            break if references.size >= MAX_RESULTS
+
+            if line.match?(regex)
+              references << {
+                file: relative_path(file),
+                line_number: line_number,
+                line: line.chomp.slice(0, 500)
+              }
+            end
+          end
+        end
+      rescue ArgumentError, Encoding::InvalidByteSequenceError, Encoding::UndefinedConversionError
+        # Skip files with encoding issues
+      end
+
+    end
+  end
+end
+
+Rubyn::Tools::Registry.register("find_references", Rubyn::Tools::FindReferences)

data/lib/rubyn/tools/git_commit.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "open3"
+require "shellwords"
+require_relative "base_tool"
+require_relative "registry"
+
+module Rubyn
+  module Tools
+    class GitCommit < BaseTool
+      DESCRIPTION = "Stage files and create a git commit"
+      PARAMETERS = {
+        message: { type: :string, description: "Commit message", required: true },
+        files: { type: :array, description: "Specific files to stage (defaults to all changed)", required: false }
+      }.freeze
+      REQUIRES_CONFIRMATION = true
+
+      def execute(params)
+        message = params[:message]
+        return error("message is required") unless message && !message.strip.empty?
+
+        files = params[:files]
+
+        # Stage files
+        add_command = if files.is_a?(Array) && !files.empty?
+                        escaped_files = files.map { |f| Shellwords.escape(f) }.join(" ")
+                        "git add #{escaped_files}"
+                      else
+                        "git add -A"
+                      end
+
+        begin
+          _stdout, stderr, status = Open3.capture3(add_command, chdir: project_root)
+        rescue StandardError => e
+          return error("Failed to stage files: #{e.message}")
+        end
+
+        return error("git add failed: #{stderr}") unless status.exitstatus.zero?
+
+        # Create commit
+        begin
+          stdout, stderr, status = Open3.capture3("git", "commit", "-m", message, chdir: project_root)
+        rescue StandardError => e
+          return error("Failed to create commit: #{e.message}")
+        end
+
+        return error("git commit failed: #{stderr}") unless status.exitstatus.zero?
+
+        # Extract commit hash
+        commit_hash = extract_commit_hash(stdout)
+
+        success(hash: commit_hash, message: message)
+      end
+
+      private
+
+      def extract_commit_hash(output)
+        match = output.match(%r{\[[\w\-/]+\s+([a-f0-9]+)\]})
+        match ? match[1] : "unknown"
+      end
+    end
+
+    Registry.register("git_commit", GitCommit)
+  end
+end

data/lib/rubyn/tools/git_create_branch.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "open3"
+require_relative "base_tool"
+require_relative "registry"
+
+module Rubyn
+  module Tools
+    class GitCreateBranch < BaseTool
+      DESCRIPTION = "Create and checkout a new git branch"
+      PARAMETERS = {
+        branch_name: { type: :string, description: "Name of the new branch", required: true },
+        from: { type: :string, description: "Base branch (defaults to current branch)", required: false }
+      }.freeze
+      REQUIRES_CONFIRMATION = true
+
+      VALID_BRANCH_PATTERN = %r{\A[a-zA-Z0-9\-_/]+\z}
+
+      def execute(params)
+        branch_name = params[:branch_name]
+        return error("branch_name is required") unless branch_name && !branch_name.strip.empty?
+
+        unless branch_name.match?(VALID_BRANCH_PATTERN)
+          return error(
+            "Invalid branch name: '#{branch_name}'. Use letters, numbers, hyphens, underscores, or slashes."
+          )
+        end
+
+        from = params[:from]
+        if from && !from.strip.empty?
+          unless from.match?(VALID_BRANCH_PATTERN)
+            return error(
+              "Invalid base branch name: '#{from}'. Use letters, numbers, hyphens, underscores, or slashes."
+            )
+          end
+        end
+
+        cmd = if from && !from.strip.empty?
+                ["git", "checkout", "-b", branch_name, from]
+              else
+                ["git", "checkout", "-b", branch_name]
+              end
+
+        begin
+          _, stderr, status = Open3.capture3(*cmd, chdir: project_root)
+        rescue StandardError => e
+          return error("Failed to create branch: #{e.message}")
+        end
+
+        return error("git checkout failed: #{stderr}") unless status.exitstatus.zero?
+
+        success(branch: branch_name)
+      end
+    end
+
+    Registry.register("git_create_branch", GitCreateBranch)
+  end
+end

data/lib/rubyn/tools/git_diff.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "open3"
+require "shellwords"
+require_relative "base_tool"
+require_relative "registry"
+
+module Rubyn
+  module Tools
+    class GitDiff < BaseTool
+      DESCRIPTION = "Show current git diff"
+      PARAMETERS = {
+        path: { type: :string, description: "Specific file to diff", required: false },
+        staged: { type: :boolean, description: "Show staged changes (default false)", required: false }
+      }.freeze
+      REQUIRES_CONFIRMATION = false
+
+      DEFAULT_MAX_OUTPUT_LENGTH = 15_000
+
+      def execute(params)
+        command = "git diff"
+        command = "#{command} --cached" if params[:staged]
+        command = "#{command} -- #{Shellwords.shellescape(params[:path])}" if params[:path] && !params[:path].strip.empty?
+
+        begin
+          stdout, stderr, status = Open3.capture3(command, chdir: project_root)
+        rescue StandardError => e
+          return error("Failed to get git diff: #{e.message}")
+        end
+
+        return error("git diff failed: #{stderr}") unless status.exitstatus.zero?
+
+        diff = truncate_output(stdout)
+        success(diff: diff)
+      end
+
+      private
+    end
+
+    Registry.register("git_diff", GitDiff)
+  end
+end

data/lib/rubyn/tools/git_log.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "open3"
+require "shellwords"
+require_relative "base_tool"
+require_relative "registry"
+
+module Rubyn
+  module Tools
+    class GitLog < BaseTool
+      DESCRIPTION = "Show recent git commit history"
+      PARAMETERS = {
+        count: { type: :integer, description: "Number of commits to show (default 10)", required: false },
+        path: { type: :string, description: "Filter by file path", required: false }
+      }.freeze
+      REQUIRES_CONFIRMATION = false
+      DEFAULT_COUNT = 10
+
+      def execute(params)
+        count = (params[:count] || DEFAULT_COUNT).to_i
+        command = "git log --oneline -#{count}"
+        command = "#{command} -- #{Shellwords.shellescape(params[:path])}" if params[:path] && !params[:path].strip.empty?
+
+        begin
+          stdout, stderr, status = Open3.capture3(command, chdir: project_root)
+        rescue StandardError => e
+          return error("Failed to get git log: #{e.message}")
+        end
+
+        return error("git log failed: #{stderr}") unless status.exitstatus.zero?
+
+        commits = stdout.strip.split("\n").map do |line|
+          hash, *message_parts = line.split
+          { hash: hash, message: message_parts.join(" ") }
+        end
+
+        success(commits: commits)
+      end
+    end
+
+    Registry.register("git_log", GitLog)
+  end
+end

data/lib/rubyn/tools/git_status.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "open3"
+require_relative "base_tool"
+require_relative "registry"
+
+module Rubyn
+  module Tools
+    class GitStatus < BaseTool
+      DESCRIPTION = "Show git working tree status"
+      PARAMETERS = {}.freeze
+      REQUIRES_CONFIRMATION = false
+
+      def execute(_params)
+        stdout, stderr, status = Open3.capture3("git status --short", chdir: project_root)
+        return error("git status failed: #{stderr}") unless status.exitstatus.zero?
+
+        success(status: stdout, clean: stdout.strip.empty?)
+      rescue Errno::ENOENT, Errno::EACCES => e
+        error("Failed to get git status: #{e.message}")
+      end
+    end
+
+    Registry.register("git_status", GitStatus)
+  end
+end

data/lib/rubyn/tools/list_directory.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Rubyn
+  module Tools
+    class ListDirectory < BaseTool
+      DESCRIPTION = "List files and directories at a given path"
+      PARAMETERS = {
+        path: { type: "string", required: false, description: "Directory path (defaults to project root)" },
+        recursive: { type: "boolean", required: false, description: "List recursively (default false)" }
+      }.freeze
+      REQUIRES_CONFIRMATION = false
+
+      MAX_ENTRIES = 500
+
+      def execute(params)
+        target_path = params[:path] || "."
+        recursive = params[:recursive] || false
+
+        resolved = resolve_path(target_path)
+        return resolved if resolved.is_a?(Hash) && resolved[:error]
+
+        return error("Directory not found: #{target_path}") unless Dir.exist?(resolved)
+
+        entries = if recursive
+                    list_recursive(resolved)
+                  else
+                    list_flat(resolved)
+                  end
+
+        success(path: relative_path(resolved), entries: entries)
+      end
+
+      private
+
+      def list_flat(dir)
+        entries = []
+        Dir.children(dir).sort.each do |name|
+          break if entries.size >= MAX_ENTRIES
+
+          next if excluded?(name)
+
+          full = File.join(dir, name)
+          entries << entry_info(name, full)
+        end
+        entries
+      end
+
+      def list_recursive(dir, prefix: "")
+        entries = []
+        Dir.children(dir).sort.each do |name|
+          return entries if entries.size >= MAX_ENTRIES
+
+          next if excluded?(name)
+
+          full = File.join(dir, name)
+          rel = prefix.empty? ? name : File.join(prefix, name)
+
+          entries << entry_info(rel, full)
+
+          entries.concat(list_recursive(full, prefix: rel)) if File.directory?(full)
+        end
+        entries
+      end
+
+      def entry_info(name, full_path)
+        if File.directory?(full_path)
+          { name: name, type: "directory", size: 0 }
+        else
+          { name: name, type: "file", size: File.size(full_path) }
+        end
+      rescue SystemCallError
+        { name: name, type: "unknown", size: 0 }
+      end
+
+      def excluded?(name)
+        EXCLUDED_DIRS.any? { |ex| name == ex || name.start_with?("#{ex}/") }
+      end
+    end
+  end
+end
+
+Rubyn::Tools::Registry.register("list_directory", Rubyn::Tools::ListDirectory)

data/lib/rubyn/tools/move_file.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "base_tool"
+require_relative "registry"
+
+module Rubyn
+  module Tools
+    class MoveFile < BaseTool
+      DESCRIPTION = "Move or rename a file"
+      PARAMETERS = {
+        source: { type: :string, description: "Path to the source file", required: true },
+        destination: { type: :string, description: "Path to the destination", required: true }
+      }.freeze
+      REQUIRES_CONFIRMATION = true
+
+      def execute(params)
+        resolved_source = resolve_path(params[:source])
+        return resolved_source if resolved_source.is_a?(Hash) && resolved_source[:error]
+
+        resolved_destination = resolve_path(params[:destination])
+        return resolved_destination if resolved_destination.is_a?(Hash) && resolved_destination[:error]
+
+        return error("Source file not found: #{params[:source]}") unless File.exist?(resolved_source)
+
+        FileUtils.mkdir_p(File.dirname(resolved_destination))
+        FileUtils.mv(resolved_source, resolved_destination)
+
+        success(source: params[:source], destination: params[:destination])
+      end
+    end
+
+    Registry.register("move_file", MoveFile)
+  end
+end

data/lib/rubyn/tools/patch_file.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+require_relative "registry"
+
+module Rubyn
+  module Tools
+    class PatchFile < BaseTool
+      DESCRIPTION = "Apply a targeted find-and-replace edit to a file"
+      PARAMETERS = {
+        path: { type: :string, description: "Path to the file to patch", required: true },
+        find: { type: :string, description: "The string to find in the file", required: true },
+        replace: { type: :string, description: "The string to replace with", required: true },
+        all_occurrences: { type: :boolean, description: "Replace all occurrences (default: false)", required: false }
+      }.freeze
+      REQUIRES_CONFIRMATION = true
+
+      def execute(params)
+        resolved = resolve_path(params[:path])
+        return resolved if resolved.is_a?(Hash) && resolved[:error]
+
+        return error("File not found: #{params[:path]}") unless File.exist?(resolved)
+
+        content = File.read(resolved)
+        find = params[:find]
+
+        return error("Find string not found in file: #{params[:path]}") unless content.include?(find)
+
+        all_occurrences = params[:all_occurrences] || false
+
+        if all_occurrences
+          replacements = content.scan(find).length
+          new_content = content.gsub(find, params[:replace])
+        else
+          replacements = 1
+          new_content = content.sub(find, params[:replace])
+        end
+
+        File.write(resolved, new_content)
+
+        success(path: params[:path], replacements: replacements)
+      end
+    end
+
+    Registry.register("patch_file", PatchFile)
+  end
+end

data/lib/rubyn/tools/rails_generate.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "open3"
+require_relative "base_tool"
+require_relative "registry"
+
+module Rubyn
+  module Tools
+    class RailsGenerate < BaseTool
+      DESCRIPTION = "Run a Rails generator"
+      PARAMETERS = {
+        generator: { type: :string, description: "Generator name (e.g. migration, model)", required: true },
+        args: { type: :string, description: "Generator arguments (e.g. AddDeletedAtToOrders deleted_at:datetime)",
+                required: true }
+      }.freeze
+      REQUIRES_CONFIRMATION = true
+
+      def execute(params)
+        generator = params[:generator]
+        args = params[:args]
+        return error("generator is required") unless generator && !generator.strip.empty?
+        return error("args is required") unless args && !args.strip.empty?
+
+        command = "bundle exec rails generate #{generator} #{args}"
+
+        begin
+          stdout, stderr, status = Open3.capture3(command, chdir: project_root)
+        rescue StandardError => e
+          return error("Failed to run rails generate: #{e.message}")
+        end
+
+        return error("rails generate failed: #{stderr}") unless status.exitstatus.zero?
+
+        success(output: stdout)
+      end
+    end
+
+    Registry.register("rails_generate", RailsGenerate)
+  end
+end

data/lib/rubyn/tools/rails_migrate.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "open3"
+require_relative "base_tool"
+require_relative "registry"
+
+module Rubyn
+  module Tools
+    class RailsMigrate < BaseTool
+      DESCRIPTION = "Run pending database migrations"
+      PARAMETERS = {
+        direction: { type: :string, description: "Migration direction: up or down (default up)", required: false },
+        version: { type: :string, description: "Specific migration version", required: false }
+      }.freeze
+      REQUIRES_CONFIRMATION = true
+
+      def execute(params)
+        direction = (params[:direction] || "up").strip.downcase
+        version = params[:version]
+
+        command = build_command(direction, version)
+        return command if command.is_a?(Hash) && command[:error]
+
+        begin
+          stdout, stderr, status = Open3.capture3(command, chdir: project_root)
+        rescue StandardError => e
+          return error("Failed to run migration: #{e.message}")
+        end
+
+        return error("Migration failed: #{stderr}") unless status.exitstatus.zero?
+
+        success(output: stdout)
+      end
+
+      private
+
+      def build_command(direction, version)
+        case direction
+        when "up"
+          "bundle exec rails db:migrate"
+        when "down"
+          if version && !version.strip.empty?
+            "bundle exec rails db:migrate:down VERSION=#{version}"
+          else
+            "bundle exec rails db:rollback"
+          end
+        else
+          error("Invalid direction: #{direction}. Must be 'up' or 'down'")
+        end
+      end
+    end
+
+    Registry.register("rails_migrate", RailsMigrate)
+  end
+end

data/lib/rubyn/tools/rails_routes.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "open3"
+require "shellwords"
+require_relative "base_tool"
+require_relative "registry"
+
+module Rubyn
+  module Tools
+    class RailsRoutes < BaseTool
+      DESCRIPTION = "Show Rails routes, optionally filtered by a pattern"
+      PARAMETERS = {
+        pattern: { type: :string, description: "Grep filter for routes", required: false }
+      }.freeze
+      REQUIRES_CONFIRMATION = false
+
+      def execute(params)
+        command = "bundle exec rails routes"
+        command = "#{command} -g #{Shellwords.shellescape(params[:pattern])}" if params[:pattern] && !params[:pattern].strip.empty?
+
+        begin
+          stdout, stderr, status = Open3.capture3(command, chdir: project_root)
+        rescue StandardError => e
+          return error("Failed to run rails routes: #{e.message}")
+        end
+
+        return error("rails routes failed: #{stderr}") unless status.exitstatus.zero?
+
+        success(routes: stdout)
+      end
+    end
+
+    Registry.register("rails_routes", RailsRoutes)
+  end
+end

data/lib/rubyn/tools/read_file.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+require_relative "registry"
+
+module Rubyn
+  module Tools
+    class ReadFile < BaseTool
+      DESCRIPTION = "Read the contents of a file"
+      PARAMETERS = {
+        path: { type: :string, description: "Path to the file to read", required: true },
+        line_start: { type: :integer, description: "Starting line number (1-based)", required: false },
+        line_end: { type: :integer, description: "Ending line number (1-based, inclusive)", required: false }
+      }.freeze
+      REQUIRES_CONFIRMATION = false
+
+      def execute(params)
+        resolved = resolve_path(params[:path])
+        return resolved if resolved.is_a?(Hash) && resolved[:error]
+
+        return error("File not found: #{params[:path]}") unless File.exist?(resolved)
+
+        return error("Not a file: #{params[:path]}") unless File.file?(resolved)
+
+        lines = File.readlines(resolved)
+        total_lines = lines.length
+
+        line_start = params[:line_start]&.to_i
+        line_end = params[:line_end]&.to_i
+
+        return success(path: params[:path], content: lines.join, line_count: total_lines) unless line_start || line_end
+
+        line_start = [line_start || 1, 1].max
+        line_end = [line_end || total_lines, total_lines].min
+
+        return error("line_start (#{line_start}) cannot be greater than line_end (#{line_end})") if line_start > line_end
+
+        content = lines[(line_start - 1)..(line_end - 1)].join
+        success(path: params[:path], content: content, line_count: total_lines)
+      end
+    end
+
+    Registry.register("read_file", ReadFile)
+  end
+end

data/lib/rubyn/tools/registry.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Rubyn
+  module Tools
+    class Registry
+      class << self
+        def register(name, klass)
+          @tools ||= {}
+          @tools[name.to_s] = klass
+        end
+
+        def get(name)
+          @tools ||= {}
+          @tools[name.to_s]
+        end
+
+        def all
+          @tools ||= {}
+          @tools.dup
+        end
+
+        def tool_definitions
+          all.map { |name, klass| { name: name, description: klass::DESCRIPTION, parameters: klass::PARAMETERS } }
+        end
+      end
+    end
+  end
+end