rubyn 0.1.0

data/lib/rubyn/tools/run_command.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "open3"
+require "timeout"
+require_relative "base_tool"
+require_relative "registry"
+
+module Rubyn
+  module Tools
+    class RunCommand < BaseTool
+      DESCRIPTION = "Execute a shell command in the project directory"
+      PARAMETERS = {
+        command: { type: :string, description: "Shell command to execute", required: true },
+        timeout: { type: :integer, description: "Timeout in seconds (default 30)", required: false }
+      }.freeze
+      REQUIRES_CONFIRMATION = true
+
+      DEFAULT_TIMEOUT = 30
+
+      def execute(params)
+        command = params[:command]
+        return error("command is required") unless command && !command.strip.empty?
+
+        timeout_seconds = (params[:timeout] || DEFAULT_TIMEOUT).to_i
+
+        stdout, stderr, status = nil
+        begin
+          Timeout.timeout(timeout_seconds) do
+            stdout, stderr, status = Open3.capture3(command, chdir: project_root)
+          end
+        rescue Timeout::Error
+          return error("Command timed out after #{timeout_seconds} seconds")
+        rescue StandardError => e
+          return error("Failed to execute command: #{e.message}")
+        end
+
+        stdout = truncate_output(stdout)
+        stderr = truncate_output(stderr)
+
+        success(command: command, stdout: stdout, stderr: stderr, exit_code: status.exitstatus)
+      end
+
+      private
+    end
+
+    Registry.register("run_command", RunCommand)
+  end
+end

data/lib/rubyn/tools/run_tests.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "open3"
+require_relative "base_tool"
+require_relative "registry"
+
+module Rubyn
+  module Tools
+    class RunTests < BaseTool
+      DESCRIPTION = "Run tests for a specific file or the full test suite"
+      PARAMETERS = {
+        path: { type: :string, description: "Specific test file to run", required: false },
+        options: { type: :string, description: "Extra flags like --fail-fast", required: false }
+      }.freeze
+      REQUIRES_CONFIRMATION = true
+
+      def execute(params)
+        command = detect_test_command
+        return error("No test framework detected (no spec/ or test/ directory found)") unless command
+
+        command = "#{command} #{params[:path]}" if params[:path] && !params[:path].strip.empty?
+        command = "#{command} #{params[:options]}" if params[:options] && !params[:options].strip.empty?
+
+        begin
+          stdout, stderr, status = Open3.capture3(command, chdir: project_root)
+        rescue StandardError => e
+          return error("Failed to run tests: #{e.message}")
+        end
+
+        success(
+          command: command,
+          stdout: stdout,
+          stderr: stderr,
+          exit_code: status.exitstatus,
+          passed: status.exitstatus.zero?
+        )
+      end
+
+      private
+
+      def detect_test_command
+        if Dir.exist?(File.join(project_root, "spec"))
+          "bundle exec rspec"
+        elsif Dir.exist?(File.join(project_root, "test"))
+          "bundle exec rails test"
+        end
+      end
+    end
+
+    Registry.register("run_tests", RunTests)
+  end
+end

data/lib/rubyn/tools/search_files.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Rubyn
+  module Tools
+    class SearchFiles < BaseTool
+      DESCRIPTION = "Search file contents for a pattern (grep)"
+      PARAMETERS = {
+        pattern: { type: "string", required: true, description: "Search pattern (regular expression)" },
+        path: { type: "string", required: false, description: "Directory to search in (defaults to project root)" },
+        file_pattern: { type: "string", required: false, description: "File glob pattern to filter (e.g. '*.rb')" }
+      }.freeze
+      REQUIRES_CONFIRMATION = false
+
+      MAX_MATCHES = 100
+      MAX_LINE_LENGTH = 500
+      MAX_FILE_SIZE = 2_000_000
+
+      def execute(params)
+        return error("Missing required parameter: pattern") unless params[:pattern]
+
+        begin
+          regex = Regexp.new(params[:pattern])
+        rescue RegexpError => e
+          return error("Invalid regex pattern: #{e.message}")
+        end
+
+        search_path = params[:path] || "."
+        file_pattern = params[:file_pattern]
+
+        resolved = resolve_path(search_path)
+        return resolved if resolved.is_a?(Hash) && resolved[:error]
+
+        return error("Path not found: #{search_path}") unless File.exist?(resolved)
+
+        matches = []
+        glob = file_pattern ? File.join(resolved, "**", file_pattern) : File.join(resolved, "**", "*")
+
+        Dir.glob(glob).each do |file|
+          break if matches.size >= MAX_MATCHES
+          next unless File.file?(file)
+          next if excluded?(file)
+          next if binary?(file)
+
+          search_in_file(file, regex, matches)
+        end
+
+        success(pattern: params[:pattern], matches: matches)
+      end
+
+      private
+
+      def search_in_file(file, regex, matches)
+        File.open(file, "r:UTF-8") do |f|
+          f.each_line.with_index(1) do |line, line_number|
+            break if matches.size >= MAX_MATCHES
+
+            if line.match?(regex)
+              matches << {
+                file: relative_path(file),
+                line_number: line_number,
+                line: line.chomp.slice(0, MAX_LINE_LENGTH)
+              }
+            end
+          end
+        end
+      rescue ArgumentError, Encoding::InvalidByteSequenceError, Encoding::UndefinedConversionError
+        # Skip files with encoding issues
+      end
+
+      def binary?(file)
+        return true if File.size(file) > MAX_FILE_SIZE
+
+        sample = File.read(file, 8192) || ""
+        sample.include?("\x00")
+      rescue Errno::EACCES, Errno::ENOENT, IOError
+        true
+      end
+    end
+  end
+end
+
+Rubyn::Tools::Registry.register("search_files", Rubyn::Tools::SearchFiles)

data/lib/rubyn/tools/write_file.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "base_tool"
+require_relative "registry"
+
+module Rubyn
+  module Tools
+    class WriteFile < BaseTool
+      DESCRIPTION = "Write content to a file, creating or overwriting it"
+      PARAMETERS = {
+        path: { type: :string, description: "Path to the file to write", required: true },
+        content: { type: :string, description: "Content to write to the file", required: true }
+      }.freeze
+      REQUIRES_CONFIRMATION = true
+
+      def execute(params)
+        resolved = resolve_path(params[:path])
+        return resolved if resolved.is_a?(Hash) && resolved[:error]
+
+        FileUtils.mkdir_p(File.dirname(resolved))
+        bytes_written = File.write(resolved, params[:content])
+
+        success(path: params[:path], bytes_written: bytes_written)
+      end
+    end
+
+    Registry.register("write_file", WriteFile)
+  end
+end

data/lib/rubyn/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Rubyn
+  VERSION = "0.1.0"
+end

data/lib/rubyn/version_checker.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "fileutils"
+
+module Rubyn
+  class VersionChecker
+    CACHE_FILE = File.join(Dir.home, ".rubyn", "version_cache.json")
+    CACHE_TTL = 86_400 # 24 hours
+    RUBYGEMS_URL = "https://rubygems.org/api/v1/versions/rubyn/latest.json"
+
+    class << self
+      def check
+        cached = read_cache
+        return cached if cached
+
+        latest = fetch_latest_version
+        return nil unless latest
+
+        write_cache(latest)
+        latest
+      rescue Net::HTTPError, SocketError, JSON::ParserError, Errno::ENOENT, Errno::EACCES
+        nil
+      end
+
+      def update_available?
+        latest = check
+        return false unless latest && Gem::Version.correct?(latest)
+
+        Gem::Version.new(latest) > Gem::Version.new(Rubyn::VERSION)
+      end
+
+      def update_message
+        latest = check
+        return nil unless latest && Gem::Version.correct?(latest)
+        return nil unless Gem::Version.new(latest) > Gem::Version.new(Rubyn::VERSION)
+
+        "Rubyn #{latest} is available (you have #{Rubyn::VERSION}). Run `gem update rubyn` to upgrade."
+      end
+
+      private
+
+      def fetch_latest_version
+        uri = URI(RUBYGEMS_URL)
+        response = Net::HTTP.get_response(uri)
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        data = JSON.parse(response.body)
+        data["version"]
+      rescue Net::HTTPError, SocketError, JSON::ParserError, Timeout::Error, Errno::ECONNREFUSED
+        nil
+      end
+
+      def read_cache
+        return nil unless File.exist?(CACHE_FILE)
+
+        data = JSON.parse(File.read(CACHE_FILE))
+        return nil if Time.now.to_i - data["checked_at"].to_i > CACHE_TTL
+
+        data["version"]
+      rescue JSON::ParserError, Errno::ENOENT, Errno::EACCES
+        nil
+      end
+
+      def write_cache(version)
+        FileUtils.mkdir_p(File.dirname(CACHE_FILE))
+        File.write(CACHE_FILE, JSON.generate(version: version, checked_at: Time.now.to_i))
+      rescue Errno::EACCES, Errno::ENOENT, Errno::ENOSPC
+        # Non-critical — skip if we can't write cache
+      end
+    end
+  end
+end

data/lib/rubyn.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+begin
+  require "dotenv/load"
+rescue LoadError
+  # dotenv is optional — only needed for local development with .env files
+end
+
+require_relative "rubyn/version"
+require_relative "rubyn/version_checker"
+
+module Rubyn
+  class Error < StandardError; end
+  class AuthenticationError < Error; end
+  class ConfigurationError < Error; end
+  class APIError < Error; end
+
+  class Configuration
+    attr_accessor :api_url, :api_key
+
+    def initialize
+      @api_url = ENV.fetch("RUBYN_API_URL", "https://app.rubyn.ai")
+      @api_key = ENV.fetch("RUBYN_API_KEY", nil)
+    end
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def api_client
+      @api_client ||= Client::ApiClient.new
+    end
+
+    def reset!
+      @configuration = nil
+      @api_client = nil
+    end
+  end
+end
+
+require_relative "rubyn/config/credentials"
+require_relative "rubyn/config/settings"
+require_relative "rubyn/config/project_config"
+require_relative "rubyn/client/api_client"
+require_relative "rubyn/context/project_scanner"
+require_relative "rubyn/context/file_resolver"
+require_relative "rubyn/context/context_builder"
+require_relative "rubyn/context/codebase_indexer"
+require_relative "rubyn/output/formatter"
+require_relative "rubyn/output/diff_renderer"
+require_relative "rubyn/output/spinner"
+require_relative "rubyn/tools/registry"
+require_relative "rubyn/tools/base_tool"
+require_relative "rubyn/tools/executor"
+require_relative "rubyn/tools/read_file"
+require_relative "rubyn/tools/write_file"
+require_relative "rubyn/tools/create_file"
+require_relative "rubyn/tools/patch_file"
+require_relative "rubyn/tools/delete_file"
+require_relative "rubyn/tools/move_file"
+require_relative "rubyn/tools/list_directory"
+require_relative "rubyn/tools/find_files"
+require_relative "rubyn/tools/search_files"
+require_relative "rubyn/tools/find_references"
+require_relative "rubyn/tools/run_command"
+require_relative "rubyn/tools/run_tests"
+require_relative "rubyn/tools/rails_routes"
+require_relative "rubyn/tools/rails_generate"
+require_relative "rubyn/tools/rails_migrate"
+require_relative "rubyn/tools/bundle_add"
+require_relative "rubyn/tools/git_status"
+require_relative "rubyn/tools/git_diff"
+require_relative "rubyn/tools/git_log"
+require_relative "rubyn/tools/git_commit"
+require_relative "rubyn/tools/git_create_branch"
+require_relative "rubyn/commands/base"
+require_relative "rubyn/commands/init"
+require_relative "rubyn/commands/refactor"
+require_relative "rubyn/commands/spec"
+require_relative "rubyn/commands/review"
+require_relative "rubyn/commands/agent"
+require_relative "rubyn/commands/index"
+require_relative "rubyn/commands/usage"
+require_relative "rubyn/commands/config"
+require_relative "rubyn/commands/dashboard"
+require_relative "rubyn/cli"
+
+# Load Rails engine when running inside a Rails app
+require_relative "rubyn/engine/engine" if defined?(Rails::Engine)

data/sig/rubyn.rbs

@@ -0,0 +1,4 @@
+module Rubyn
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end