rubyn-code 0.1.0

data/lib/rubyn_code/tools/read_file.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "registry"
+
+module RubynCode
+  module Tools
+    class ReadFile < Base
+      TOOL_NAME = "read_file"
+      DESCRIPTION = "Reads a file from the filesystem. Returns file content with line numbers prepended."
+      PARAMETERS = {
+        path: { type: :string, required: true, description: "Path to the file to read (relative to project root or absolute)" },
+        offset: { type: :integer, required: false, description: "Line number to start reading from (1-based)" },
+        limit: { type: :integer, required: false, description: "Number of lines to read" }
+      }.freeze
+      RISK_LEVEL = :read
+      REQUIRES_CONFIRMATION = false
+
+      def execute(path:, offset: nil, limit: nil)
+        resolved = read_file_safely(path)
+
+        lines = File.readlines(resolved)
+
+        start_line = offset ? [offset.to_i - 1, 0].max : 0
+        end_line = limit ? start_line + limit.to_i : lines.length
+
+        selected = lines[start_line...end_line] || []
+
+        selected.each_with_index.map do |line, idx|
+          line_num = start_line + idx + 1
+          "#{line_num.to_s.rjust(6)}\t#{line}"
+        end.join
+      end
+    end
+
+    Registry.register(ReadFile)
+  end
+end

data/lib/rubyn_code/tools/read_inbox.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "registry"
+
+module RubynCode
+  module Tools
+    # Tool for reading unread messages from a teammate's inbox.
+    class ReadInbox < Base
+      TOOL_NAME = "read_inbox"
+      DESCRIPTION = "Reads all unread messages from the agent's inbox and marks them as read."
+      PARAMETERS = {
+        name: { type: :string, required: true, description: "The agent name whose inbox to read" }
+      }.freeze
+      RISK_LEVEL = :read
+      REQUIRES_CONFIRMATION = false
+
+      # @param project_root [String]
+      # @param mailbox [Teams::Mailbox] the team mailbox instance
+      def initialize(project_root:, mailbox:)
+        super(project_root: project_root)
+        @mailbox = mailbox
+      end
+
+      # Reads and returns all unread messages for the given agent.
+      #
+      # @param name [String] the reader's agent name
+      # @return [String] formatted messages or a notice if the inbox is empty
+      def execute(name:)
+        raise Error, "Agent name is required" if name.nil? || name.strip.empty?
+
+        messages = @mailbox.read_inbox(name)
+
+        return "No unread messages for '#{name}'." if messages.empty?
+
+        formatted = messages.map.with_index(1) do |msg, idx|
+          format_message(idx, msg)
+        end
+
+        header = "#{messages.size} message#{'s' if messages.size != 1} for '#{name}':\n"
+        header + formatted.join("\n")
+      end
+
+      private
+
+      # Formats a single message for display.
+      #
+      # @param index [Integer] message number
+      # @param msg [Hash] the parsed message hash
+      # @return [String]
+      def format_message(index, msg)
+        lines = []
+        lines << "--- Message #{index} ---"
+        lines << "  From: #{msg[:from]}"
+        lines << "  Type: #{msg[:message_type]}"
+        lines << "  Time: #{msg[:timestamp]}"
+        lines << "  Content: #{msg[:content]}"
+        lines.join("\n")
+      end
+    end
+
+    Registry.register(ReadInbox)
+  end
+end

data/lib/rubyn_code/tools/registry.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Tools
+    module Registry
+      @tools = {}
+
+      class << self
+        def register(tool_class)
+          name = tool_class.tool_name
+          @tools[name] = tool_class
+        end
+
+        def get(name)
+          @tools.fetch(name) do
+            raise ToolNotFoundError, "Unknown tool: #{name}. Available: #{tool_names.join(', ')}"
+          end
+        end
+
+        def all
+          @tools.values
+        end
+
+        def tool_definitions
+          @tools.values.map(&:to_schema)
+        end
+
+        def tool_names
+          @tools.keys.sort
+        end
+
+        def reset!
+          @tools = {}
+        end
+
+        def load_all!
+          tool_files = Dir[File.join(__dir__, "*.rb")]
+          tool_files.each do |file|
+            basename = File.basename(file, ".rb")
+            next if %w[base registry schema executor].include?(basename)
+
+            require_relative basename
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/tools/review_pr.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "registry"
+
+module RubynCode
+  module Tools
+    class ReviewPr < Base
+      TOOL_NAME = "review_pr"
+      DESCRIPTION = "Review current branch changes against Ruby/Rails best practices. " \
+                    "Gets the diff of the current branch vs the base branch, analyzes each changed file, " \
+                    "and provides actionable suggestions with explanations."
+      PARAMETERS = {
+        base_branch: {
+          type: :string,
+          description: "Base branch to diff against (default: main)",
+          required: false
+        },
+        focus: {
+          type: :string,
+          description: "Focus area: 'all', 'security', 'performance', 'style', 'testing' (default: all)",
+          required: false
+        }
+      }.freeze
+      RISK_LEVEL = :read
+
+      def execute(base_branch: "main", focus: "all")
+        # Check git is available
+        unless system("git rev-parse --is-inside-work-tree > /dev/null 2>&1", chdir: project_root)
+          return "Error: Not a git repository or git is not installed."
+        end
+
+        # Get current branch
+        current = run_git("rev-parse --abbrev-ref HEAD").strip
+        return "Error: Could not determine current branch." if current.empty?
+
+        if current == base_branch
+          return "You're on #{base_branch}. Switch to a feature branch first, or specify a different base: review_pr(base_branch: 'develop')"
+        end
+
+        # Check base branch exists
+        unless run_git("rev-parse --verify #{base_branch} 2>/dev/null").strip.length > 0
+          # Try origin/main
+          base_branch = "origin/#{base_branch}"
+          unless run_git("rev-parse --verify #{base_branch} 2>/dev/null").strip.length > 0
+            return "Error: Base branch '#{base_branch}' not found."
+          end
+        end
+
+        # Get the diff
+        diff = run_git("diff #{base_branch}...HEAD")
+        return "No changes found between #{current} and #{base_branch}." if diff.strip.empty?
+
+        # Get changed files with stats
+        stat = run_git("diff #{base_branch}...HEAD --stat")
+        files_changed = run_git("diff #{base_branch}...HEAD --name-only").strip.split("\n")
+        commit_log = run_git("log #{base_branch}..HEAD --oneline")
+
+        # Build the review context
+        ruby_files = files_changed.select { |f| f.match?(/\.(rb|rake|gemspec|ru)$/) }
+        erb_files = files_changed.select { |f| f.match?(/\.(erb|haml|slim)$/) }
+        spec_files = files_changed.select { |f| f.match?(/_spec\.rb$|_test\.rb$/) }
+        migration_files = files_changed.select { |f| f.include?("db/migrate") }
+        config_files = files_changed.select { |f| f.match?(/config\/|\.yml$|\.yaml$/) }
+
+        review = []
+        review << "# PR Review: #{current} → #{base_branch}"
+        review << ""
+        review << "## Summary"
+        review << stat
+        review << ""
+        review << "## Commits"
+        review << commit_log
+        review << ""
+        review << "## Files by Category"
+        review << "- Ruby: #{ruby_files.length} files" unless ruby_files.empty?
+        review << "- Templates: #{erb_files.length} files" unless erb_files.empty?
+        review << "- Specs: #{spec_files.length} files" unless spec_files.empty?
+        review << "- Migrations: #{migration_files.length} files" unless migration_files.empty?
+        review << "- Config: #{config_files.length} files" unless config_files.empty?
+        review << ""
+
+        # Add focus-specific review instructions
+        review << "## Review Focus: #{focus.upcase}"
+        review << review_instructions(focus)
+        review << ""
+
+        # Add the diff (truncated if too large)
+        if diff.length > 40_000
+          review << "## Diff (truncated — #{diff.length} chars total)"
+          review << diff[0...40_000]
+          review << "\n... [truncated #{diff.length - 40_000} chars]"
+        else
+          review << "## Full Diff"
+          review << diff
+        end
+
+        review << ""
+        review << "---"
+        review << "Review this diff against Ruby/Rails best practices. For each issue found:"
+        review << "1. Quote the specific code"
+        review << "2. Explain what's wrong and WHY it matters"
+        review << "3. Show the suggested fix"
+        review << "4. Rate severity: [critical] [warning] [suggestion] [nitpick]"
+        review << ""
+        review << "Also check for:"
+        review << "- Missing tests for new code"
+        review << "- N+1 queries in ActiveRecord changes"
+        review << "- Security issues (SQL injection, XSS, mass assignment)"
+        review << "- Missing database indexes for new associations"
+        review << "- Proper error handling"
+
+        truncate(review.join("\n"))
+      end
+
+      private
+
+      def run_git(command)
+        `cd #{project_root} && git #{command} 2>/dev/null`
+      end
+
+      def review_instructions(focus)
+        case focus.to_s.downcase
+        when "security"
+          "Focus on: SQL injection, XSS, CSRF, mass assignment, authentication/authorization gaps, " \
+          "sensitive data exposure, insecure dependencies, command injection, path traversal."
+        when "performance"
+          "Focus on: N+1 queries, missing indexes, eager loading, caching opportunities, " \
+          "unnecessary database calls, memory bloat, slow iterations, missing pagination."
+        when "style"
+          "Focus on: Ruby idioms, naming conventions, method length, class organization, " \
+          "frozen string literals, guard clauses, DRY violations, dead code."
+        when "testing"
+          "Focus on: Missing test coverage, test quality, factory usage, assertion quality, " \
+          "test isolation, flaky test risks, edge cases, integration vs unit test balance."
+        else
+          "Review all aspects: code quality, security, performance, testing, Rails conventions, " \
+          "Ruby idioms, and architectural patterns."
+        end
+      end
+    end
+
+    Registry.register(ReviewPr)
+  end
+end

data/lib/rubyn_code/tools/run_specs.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "open3"
+require_relative "base"
+require_relative "registry"
+
+module RubynCode
+  module Tools
+    class RunSpecs < Base
+      TOOL_NAME = "run_specs"
+      DESCRIPTION = "Runs RSpec or Minitest specs. Auto-detects which test framework is in use."
+      PARAMETERS = {
+        path: { type: :string, required: false, description: "Specific test file or directory to run" },
+        format: { type: :string, required: false, default: "documentation", description: "Output format (default: 'documentation')" },
+        fail_fast: { type: :boolean, required: false, description: "Stop on first failure" }
+      }.freeze
+      RISK_LEVEL = :execute
+      REQUIRES_CONFIRMATION = false
+
+      def execute(path: nil, format: "documentation", fail_fast: false)
+        framework = detect_framework
+
+        command = build_command(framework, path, format, fail_fast)
+        stdout, stderr, status = Open3.capture3(command, chdir: project_root)
+
+        build_output(stdout, stderr, status)
+      end
+
+      private
+
+      def detect_framework
+        gemfile_path = File.join(project_root, "Gemfile")
+
+        if File.exist?(gemfile_path)
+          content = File.read(gemfile_path)
+          return :rspec if content.match?(/['"]rspec['"]/) || content.match?(/['"]rspec-rails['"]/)
+          return :minitest if content.match?(/['"]minitest['"]/)
+        end
+
+        return :rspec if File.exist?(File.join(project_root, ".rspec"))
+        return :rspec if File.directory?(File.join(project_root, "spec"))
+        return :minitest if File.directory?(File.join(project_root, "test"))
+
+        raise Error, "Could not detect test framework. Ensure RSpec or Minitest is configured."
+      end
+
+      def build_command(framework, path, format, fail_fast)
+        case framework
+        when :rspec
+          cmd = "bundle exec rspec"
+          cmd += " --format #{format}" if format
+          cmd += " --fail-fast" if fail_fast
+          cmd += " #{path}" if path
+          cmd
+        when :minitest
+          if path
+            "bundle exec ruby -Itest #{path}"
+          else
+            "bundle exec rails test"
+          end
+        end
+      end
+
+      def build_output(stdout, stderr, status)
+        parts = []
+        parts << stdout unless stdout.empty?
+        parts << "STDERR:\n#{stderr}" unless stderr.empty?
+        parts << "Exit code: #{status.exitstatus}" unless status.success?
+        parts.empty? ? "(no output)" : parts.join("\n")
+      end
+    end
+
+    Registry.register(RunSpecs)
+  end
+end

data/lib/rubyn_code/tools/schema.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Tools
+    module Schema
+      TYPE_MAP = {
+        string: "string",
+        integer: "integer",
+        number: "number",
+        boolean: "boolean",
+        array: "array",
+        object: "object"
+      }.freeze
+
+      class << self
+        def build(params_hash)
+          return { type: "object", properties: {}, required: [] } if params_hash.empty?
+
+          properties = {}
+          required = []
+
+          params_hash.each do |name, spec|
+            name_str = name.to_s
+            prop = build_property(spec)
+            properties[name_str] = prop
+
+            required << name_str if spec[:required]
+          end
+
+          schema = {
+            type: "object",
+            properties: properties
+          }
+          schema[:required] = required unless required.empty?
+          schema
+        end
+
+        private
+
+        def build_property(spec)
+          prop = {}
+
+          type = spec[:type] || :string
+          prop[:type] = TYPE_MAP.fetch(type, type.to_s)
+
+          prop[:description] = spec[:description] if spec[:description]
+          prop[:default] = spec[:default] if spec.key?(:default)
+          prop[:enum] = spec[:enum] if spec[:enum]
+
+          if spec[:items]
+            prop[:items] = build_property(spec[:items])
+          end
+
+          prop
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/tools/send_message.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "registry"
+
+module RubynCode
+  module Tools
+    # Tool for sending messages to teammates via the team mailbox.
+    class SendMessage < Base
+      TOOL_NAME = "send_message"
+      DESCRIPTION = "Sends a message to a teammate. Used for inter-agent communication within a team."
+      PARAMETERS = {
+        to: { type: :string, required: true, description: "Name of the recipient teammate" },
+        content: { type: :string, required: true, description: "Message content to send" },
+        message_type: { type: :string, required: false, default: "message",
+                        description: 'Type of message (default: "message")' }
+      }.freeze
+      RISK_LEVEL = :write
+      REQUIRES_CONFIRMATION = false
+
+      # @param project_root [String]
+      # @param mailbox [Teams::Mailbox] the team mailbox instance
+      # @param sender_name [String] the name of the sending agent
+      def initialize(project_root:, mailbox:, sender_name:)
+        super(project_root: project_root)
+        @mailbox = mailbox
+        @sender_name = sender_name
+      end
+
+      # Sends a message to the specified teammate.
+      #
+      # @param to [String] recipient name
+      # @param content [String] message body
+      # @param message_type [String] type of message
+      # @return [String] confirmation with the message id
+      def execute(to:, content:, message_type: "message")
+        raise Error, "Recipient name is required" if to.nil? || to.strip.empty?
+        raise Error, "Message content is required" if content.nil? || content.strip.empty?
+
+        message_id = @mailbox.send(
+          from: @sender_name,
+          to: to,
+          content: content,
+          message_type: message_type
+        )
+
+        "Message sent to '#{to}' (id: #{message_id}, type: #{message_type})"
+      end
+    end
+
+    Registry.register(SendMessage)
+  end
+end

data/lib/rubyn_code/tools/spawn_agent.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "registry"
+
+module RubynCode
+  module Tools
+    class SpawnAgent < Base
+      TOOL_NAME = "spawn_agent"
+      DESCRIPTION = "Spawn an isolated sub-agent to handle a task. The sub-agent gets its own fresh context, " \
+                    "works independently, and returns only a summary. Use 'explore' type for research/reading, " \
+                    "'worker' type for writing code/files. The sub-agent shares the filesystem but not your conversation."
+      PARAMETERS = {
+        prompt: {
+          type: :string,
+          description: "The task for the sub-agent to perform",
+          required: true
+        },
+        agent_type: {
+          type: :string,
+          description: "Type of agent: 'explore' (read-only tools) or 'worker' (full write access). Default: explore",
+          required: false,
+          enum: %w[explore worker]
+        }
+      }.freeze
+      RISK_LEVEL = :execute
+
+      # These get injected by the executor or the REPL
+      attr_writer :llm_client, :on_status
+
+      def execute(prompt:, agent_type: "explore")
+        type = agent_type.to_sym
+        callback = @on_status || method(:default_status)
+        @tool_count = 0
+
+        callback.call(:started, "Spawning #{type} agent...")
+
+        tools = tools_for_type(type)
+
+        result = run_sub_agent(prompt: prompt, tools: tools, type: type, callback: callback)
+
+        callback.call(:done, "Agent finished (#{@tool_count} tool calls).")
+
+        summary = RubynCode::SubAgents::Summarizer.call(result, max_length: 3000)
+        "## Sub-Agent Result (#{type})\n\n#{summary}"
+      end
+
+      private
+
+      def run_sub_agent(prompt:, tools:, type:, callback:)
+        conversation = RubynCode::Agent::Conversation.new
+        conversation.add_user_message(prompt)
+
+        max_iterations = type == :explore ? 20 : 30
+        iteration = 0
+
+        loop do
+          break if iteration >= max_iterations
+
+          response = @llm_client.chat(
+            messages: conversation.to_api_format,
+            tools: tools,
+            system: sub_agent_system_prompt(type)
+          )
+
+          content = response.respond_to?(:content) ? Array(response.content) : []
+          tool_calls = content.select { |b| b.respond_to?(:type) && b.type == "tool_use" }
+
+          if tool_calls.empty?
+            # Final text response
+            text = content.select { |b| b.respond_to?(:type) && b.type == "text" }
+                          .map(&:text).join("\n")
+            conversation.add_assistant_message(content)
+            return text
+          end
+
+          # Add assistant message with tool calls
+          conversation.add_assistant_message(content)
+
+          # Execute each tool call
+          tool_calls.each do |tc|
+            name = tc.respond_to?(:name) ? tc.name : tc[:name]
+            input = tc.respond_to?(:input) ? tc.input : tc[:input]
+            id = tc.respond_to?(:id) ? tc.id : tc[:id]
+
+            @tool_count += 1
+            callback.call(:tool, "#{name}")
+
+            begin
+              tool_class = RubynCode::Tools::Registry.get(name)
+
+              # Block recursive spawning
+              if %w[spawn_agent].include?(name)
+                conversation.add_tool_result(id, name, "Error: Sub-agents cannot spawn other agents.", is_error: true)
+                next
+              end
+
+              # Block write tools for explore agents
+              if type == :explore && tool_class.risk_level != :read
+                conversation.add_tool_result(id, name, "Error: Explore agents can only use read-only tools.", is_error: true)
+                next
+              end
+
+              tool = tool_class.new(project_root: project_root)
+              result = tool.execute(**input.transform_keys(&:to_sym))
+              truncated = tool.truncate(result.to_s)
+
+              conversation.add_tool_result(id, name, truncated)
+            rescue StandardError => e
+              conversation.add_tool_result(id, name, "Error: #{e.message}", is_error: true)
+            end
+          end
+
+          iteration += 1
+        end
+
+        "Sub-agent reached iteration limit (#{max_iterations})."
+      end
+
+      def tools_for_type(type)
+        all_tools = RubynCode::Tools::Registry.tool_definitions
+        blocked = %w[spawn_agent send_message read_inbox compact memory_write]
+
+        if type == :explore
+          # Read-only tools
+          read_tools = %w[read_file glob grep bash load_skill memory_search]
+          all_tools.select { |t| read_tools.include?(t[:name]) }
+        else
+          # Worker gets everything except agent-spawning and team tools
+          all_tools.reject { |t| blocked.include?(t[:name]) }
+        end
+      end
+
+      def sub_agent_system_prompt(type)
+        base = "You are a Rubyn sub-agent. Complete your task efficiently and return a clear summary of what you found or did."
+
+        case type
+        when :explore
+          "#{base}\nYou have read-only access. Search, read files, and analyze. Do NOT attempt to write or modify anything."
+        when :worker
+          "#{base}\nYou have full read/write access. Make the changes needed, run tests if appropriate, and report what you did."
+        else
+          base
+        end
+      end
+
+      def default_status(type, message)
+        $stderr.puts "[sub-agent] #{message}" if ENV["RUBYN_DEBUG"]
+      end
+    end
+
+    Registry.register(SpawnAgent)
+  end
+end