rubyn-code 0.1.0

data/lib/rubyn_code/tools/executor.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Tools
+    class Executor
+      attr_reader :project_root
+      attr_accessor :llm_client, :background_worker, :on_agent_status, :db
+
+      def initialize(project_root:)
+        @project_root = File.expand_path(project_root)
+        @injections = {}
+        Registry.load_all!
+      end
+
+      def execute(tool_name, params)
+        tool_class = Registry.get(tool_name)
+        tool = tool_class.new(project_root: project_root)
+
+        # Inject dependencies for tools that need them
+        inject_dependencies(tool, tool_name)
+
+        symbolized = params.transform_keys(&:to_sym)
+        result = tool.execute(**symbolized)
+        tool.truncate(result.to_s)
+      rescue ToolNotFoundError => e
+        error_result("Tool error: #{e.message}")
+      rescue PermissionDeniedError => e
+        error_result("Permission denied: #{e.message}")
+      rescue NotImplementedError => e
+        error_result("Not implemented: #{e.message}")
+      rescue Error => e
+        error_result("Error: #{e.message}")
+      rescue StandardError => e
+        error_result("Unexpected error in #{tool_name}: #{e.class}: #{e.message}")
+      end
+
+      def tool_definitions
+        Registry.tool_definitions
+      end
+
+      private
+
+      def inject_dependencies(tool, tool_name)
+        case tool_name
+        when "spawn_agent"
+          tool.llm_client = @llm_client if tool.respond_to?(:llm_client=)
+          tool.on_status = @on_agent_status if tool.respond_to?(:on_status=)
+        when "spawn_teammate"
+          tool.llm_client = @llm_client if tool.respond_to?(:llm_client=)
+          tool.on_status = @on_agent_status if tool.respond_to?(:on_status=)
+          tool.db = @db if tool.respond_to?(:db=)
+        when "background_run"
+          tool.background_worker = @background_worker if tool.respond_to?(:background_worker=)
+        end
+      end
+
+      def error_result(message)
+        message
+      end
+    end
+  end
+end

data/lib/rubyn_code/tools/git_commit.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "open3"
+require_relative "base"
+require_relative "registry"
+
+module RubynCode
+  module Tools
+    class GitCommit < Base
+      TOOL_NAME = "git_commit"
+      DESCRIPTION = "Stage files and create a git commit. Specify files to stage or use 'all' to stage everything."
+      PARAMETERS = {
+        message: { type: :string, required: true, description: "The commit message" },
+        files: { type: :string, required: false, default: "all", description: "Space-separated file paths to stage, or 'all' to stage everything (git add -A)" }
+      }.freeze
+      RISK_LEVEL = :write
+      REQUIRES_CONFIRMATION = true
+
+      def execute(message:, files: "all")
+        validate_git_repo!
+        validate_message!(message)
+
+        stage_files(files)
+        commit_output = create_commit(message)
+
+        commit_output
+      end
+
+      private
+
+      def validate_git_repo!
+        _, _, status = Open3.capture3("git", "rev-parse", "--is-inside-work-tree", chdir: project_root)
+        unless status.success?
+          raise Error, "Not a git repository: #{project_root}"
+        end
+      end
+
+      def validate_message!(message)
+        if message.nil? || message.strip.empty?
+          raise Error, "Commit message cannot be empty"
+        end
+      end
+
+      def stage_files(files)
+        if files.strip.downcase == "all"
+          stdout, stderr, status = Open3.capture3("git", "add", "-A", chdir: project_root)
+        else
+          file_list = files.split(/\s+/).reject(&:empty?)
+          if file_list.empty?
+            raise Error, "No files specified to stage"
+          end
+
+          stdout, stderr, status = Open3.capture3("git", "add", "--", *file_list, chdir: project_root)
+        end
+
+        unless status.success?
+          raise Error, "Failed to stage files: #{stderr.strip}"
+        end
+      end
+
+      def create_commit(message)
+        stdout, stderr, status = Open3.capture3("git", "commit", "-m", message, chdir: project_root)
+
+        unless status.success?
+          if stderr.include?("nothing to commit")
+            return "Nothing to commit — working tree is clean."
+          end
+
+          raise Error, "Commit failed: #{stderr.strip}"
+        end
+
+        # Extract the commit hash from the output
+        commit_hash = extract_commit_hash
+        branch = current_branch
+
+        lines = ["Committed on branch: #{branch}"]
+        lines << "Commit: #{commit_hash}" if commit_hash
+        lines << ""
+        lines << stdout.strip
+
+        lines.join("\n")
+      end
+
+      def extract_commit_hash
+        stdout, _, status = Open3.capture3("git", "rev-parse", "--short", "HEAD", chdir: project_root)
+        status.success? ? stdout.strip : nil
+      end
+
+      def current_branch
+        stdout, _, status = Open3.capture3("git", "branch", "--show-current", chdir: project_root)
+        status.success? && !stdout.strip.empty? ? stdout.strip : "HEAD (detached)"
+      end
+    end
+
+    Registry.register(GitCommit)
+  end
+end

data/lib/rubyn_code/tools/git_diff.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "open3"
+require_relative "base"
+require_relative "registry"
+
+module RubynCode
+  module Tools
+    class GitDiff < Base
+      TOOL_NAME = "git_diff"
+      DESCRIPTION = "Show git diff for staged, unstaged, or between branches/commits."
+      PARAMETERS = {
+        target: { type: :string, required: false, default: "unstaged", description: 'What to diff: "staged", "unstaged", or a branch/commit ref (default: "unstaged")' }
+      }.freeze
+      RISK_LEVEL = :read
+      REQUIRES_CONFIRMATION = false
+
+      MAX_DIFF_LENGTH = 80_000
+
+      def execute(target: "unstaged")
+        validate_git_repo!
+
+        cmd = build_diff_command(target.to_s.strip)
+        stdout, stderr, status = Open3.capture3(*cmd, chdir: project_root)
+
+        unless status.success?
+          raise Error, "git diff failed: #{stderr.strip}"
+        end
+
+        if stdout.strip.empty?
+          "No differences found for target: #{target}"
+        else
+          header = "git diff (#{target}):\n\n"
+          truncate("#{header}#{stdout}", max: MAX_DIFF_LENGTH)
+        end
+      end
+
+      private
+
+      def validate_git_repo!
+        _, _, status = Open3.capture3("git", "rev-parse", "--is-inside-work-tree", chdir: project_root)
+        unless status.success?
+          raise Error, "Not a git repository: #{project_root}"
+        end
+      end
+
+      def build_diff_command(target)
+        case target.downcase
+        when "staged", "cached"
+          %w[git diff --cached]
+        when "unstaged", ""
+          %w[git diff]
+        else
+          ["git", "diff", target]
+        end
+      end
+    end
+
+    Registry.register(GitDiff)
+  end
+end

data/lib/rubyn_code/tools/git_log.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "open3"
+require_relative "base"
+require_relative "registry"
+
+module RubynCode
+  module Tools
+    class GitLog < Base
+      TOOL_NAME = "git_log"
+      DESCRIPTION = "Show recent git commit history."
+      PARAMETERS = {
+        count: { type: :integer, required: false, default: 20, description: "Number of commits to show (default: 20)" },
+        branch: { type: :string, required: false, description: "Branch name to show log for (default: current branch)" }
+      }.freeze
+      RISK_LEVEL = :read
+      REQUIRES_CONFIRMATION = false
+
+      def execute(count: 20, branch: nil)
+        validate_git_repo!
+
+        count = [[count.to_i, 1].max, 200].min
+
+        cmd = ["git", "log", "--oneline", "-#{count}"]
+        cmd << branch unless branch.nil? || branch.strip.empty?
+
+        stdout, stderr, status = Open3.capture3(*cmd, chdir: project_root)
+
+        unless status.success?
+          raise Error, "git log failed: #{stderr.strip}"
+        end
+
+        if stdout.strip.empty?
+          "No commits found."
+        else
+          current = current_branch
+          header = "Commit history#{branch ? " (#{branch})" : " (#{current})"}:\n\n"
+          truncate("#{header}#{stdout}", max: 50_000)
+        end
+      end
+
+      private
+
+      def validate_git_repo!
+        _, _, status = Open3.capture3("git", "rev-parse", "--is-inside-work-tree", chdir: project_root)
+        unless status.success?
+          raise Error, "Not a git repository: #{project_root}"
+        end
+      end
+
+      def current_branch
+        stdout, _, status = Open3.capture3("git", "branch", "--show-current", chdir: project_root)
+        status.success? && !stdout.strip.empty? ? stdout.strip : "HEAD (detached)"
+      end
+    end
+
+    Registry.register(GitLog)
+  end
+end

data/lib/rubyn_code/tools/git_status.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "open3"
+require_relative "base"
+require_relative "registry"
+
+module RubynCode
+  module Tools
+    class GitStatus < Base
+      TOOL_NAME = "git_status"
+      DESCRIPTION = "Show the current git status — modified, staged, and untracked files."
+      PARAMETERS = {}.freeze
+      RISK_LEVEL = :read
+      REQUIRES_CONFIRMATION = false
+
+      def execute(**_params)
+        validate_git_repo!
+
+        branch = current_branch
+        status_output = git_status
+
+        lines = ["Branch: #{branch}\n"]
+
+        if status_output.strip.empty?
+          lines << "Working tree is clean — nothing to commit."
+        else
+          lines << status_output
+        end
+
+        lines.join("\n")
+      end
+
+      private
+
+      def validate_git_repo!
+        _, _, status = Open3.capture3("git", "rev-parse", "--is-inside-work-tree", chdir: project_root)
+        unless status.success?
+          raise Error, "Not a git repository: #{project_root}"
+        end
+      end
+
+      def current_branch
+        stdout, _, status = Open3.capture3("git", "branch", "--show-current", chdir: project_root)
+        status.success? && !stdout.strip.empty? ? stdout.strip : "HEAD (detached)"
+      end
+
+      def git_status
+        stdout, stderr, status = Open3.capture3("git", "status", "--short", chdir: project_root)
+        unless status.success?
+          raise Error, "git status failed: #{stderr.strip}"
+        end
+
+        stdout
+      end
+    end
+
+    Registry.register(GitStatus)
+  end
+end

data/lib/rubyn_code/tools/glob.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "registry"
+
+module RubynCode
+  module Tools
+    class Glob < Base
+      TOOL_NAME = "glob"
+      DESCRIPTION = "File pattern matching. Returns sorted list of file paths matching the glob pattern."
+      PARAMETERS = {
+        pattern: { type: :string, required: true, description: "Glob pattern (e.g. '**/*.rb', 'app/**/*.erb')" },
+        path: { type: :string, required: false, description: "Directory to search in (defaults to project root)" }
+      }.freeze
+      RISK_LEVEL = :read
+      REQUIRES_CONFIRMATION = false
+
+      def execute(pattern:, path: nil)
+        search_dir = path ? safe_path(path) : project_root
+
+        unless File.directory?(search_dir)
+          raise Error, "Directory not found: #{path || project_root}"
+        end
+
+        full_pattern = File.join(search_dir, pattern)
+        matches = Dir.glob(full_pattern, File::FNM_DOTMATCH).sort
+
+        matches
+          .select { |f| File.file?(f) }
+          .reject { |f| File.basename(f).start_with?(".") && File.basename(f) == "." || File.basename(f) == ".." }
+          .map { |f| relative_to_root(f) }
+          .join("\n")
+      end
+
+      private
+
+      def relative_to_root(absolute_path)
+        absolute_path.delete_prefix("#{project_root}/")
+      end
+    end
+
+    Registry.register(Glob)
+  end
+end

data/lib/rubyn_code/tools/grep.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "registry"
+
+module RubynCode
+  module Tools
+    class Grep < Base
+      TOOL_NAME = "grep"
+      DESCRIPTION = "Searches file contents using regular expressions. Returns matching lines with file paths and line numbers."
+      PARAMETERS = {
+        pattern: { type: :string, required: true, description: "Regular expression pattern to search for" },
+        path: { type: :string, required: false, description: "File or directory to search in (defaults to project root)" },
+        glob_filter: { type: :string, required: false, description: "Glob pattern to filter files (e.g. '*.rb')" },
+        max_results: { type: :integer, required: false, default: 50, description: "Maximum number of matching lines to return" }
+      }.freeze
+      RISK_LEVEL = :read
+      REQUIRES_CONFIRMATION = false
+
+      def execute(pattern:, path: nil, glob_filter: nil, max_results: 50)
+        search_path = path ? safe_path(path) : project_root
+        regex = Regexp.new(pattern)
+
+        files = collect_files(search_path, glob_filter)
+        results = []
+
+        files.each do |file|
+          break if results.length >= max_results
+
+          search_file(file, regex, results, max_results)
+        end
+
+        return "No matches found for pattern: #{pattern}" if results.empty?
+
+        results.join("\n")
+      end
+
+      private
+
+      def collect_files(search_path, glob_filter)
+        if File.file?(search_path)
+          [search_path]
+        elsif File.directory?(search_path)
+          glob_pattern = glob_filter || "**/*"
+          Dir.glob(File.join(search_path, glob_pattern))
+             .select { |f| File.file?(f) }
+             .reject { |f| binary_file?(f) }
+             .sort
+        else
+          raise Error, "Path not found: #{search_path}"
+        end
+      end
+
+      def search_file(file, regex, results, max_results)
+        File.foreach(file).with_index(1) do |line, line_num|
+          break if results.length >= max_results
+
+          if line.match?(regex)
+            relative = file.delete_prefix("#{project_root}/")
+            results << "#{relative}:#{line_num}: #{line.chomp}"
+          end
+        end
+      rescue ArgumentError, Encoding::InvalidByteSequenceError
+        # Skip files with encoding issues
+      end
+
+      def binary_file?(path)
+        return true if path.match?(/\.(png|jpg|jpeg|gif|ico|woff|woff2|ttf|eot|pdf|zip|gz|tar|so|dylib|o|a)\z/i)
+
+        sample = File.read(path, 512)
+        return false if sample.nil?
+
+        sample.bytes.any? { |b| b.zero? }
+      rescue StandardError
+        true
+      end
+    end
+
+    Registry.register(Grep)
+  end
+end

data/lib/rubyn_code/tools/load_skill.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "registry"
+
+module RubynCode
+  module Tools
+    class LoadSkill < Base
+      TOOL_NAME = "load_skill"
+      DESCRIPTION = "Loads a skill document into the conversation context. Use /skill-name or provide the skill name."
+      PARAMETERS = {
+        name: { type: :string, required: true, description: "Name of the skill to load" }
+      }.freeze
+      RISK_LEVEL = :read
+      REQUIRES_CONFIRMATION = false
+
+      def initialize(project_root:, skill_loader: nil)
+        super(project_root: project_root)
+        @skill_loader = skill_loader
+      end
+
+      def execute(name:)
+        loader = @skill_loader || default_loader
+        loader.load(name)
+      end
+
+      private
+
+      def default_loader
+        skills_dirs = [
+          File.join(project_root, ".rubyn", "skills"),
+          File.join(Dir.home, ".rubyn", "skills")
+        ]
+        catalog = Skills::Catalog.new(skills_dirs)
+        Skills::Loader.new(catalog)
+      end
+    end
+
+    Registry.register(LoadSkill)
+  end
+end

data/lib/rubyn_code/tools/memory_search.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "registry"
+
+module RubynCode
+  module Tools
+    class MemorySearch < Base
+      TOOL_NAME = "memory_search"
+      DESCRIPTION = "Searches project memories using full-text search. " \
+                    "Returns relevant memories including code patterns, user preferences, " \
+                    "project conventions, error resolutions, and past decisions."
+      PARAMETERS = {
+        query: { type: :string, required: true, description: "Search query for finding relevant memories" },
+        tier: { type: :string, required: false, description: "Filter by memory tier: short, medium, or long" },
+        category: { type: :string, required: false, description: "Filter by category: code_pattern, user_preference, project_convention, error_resolution, or decision" },
+        limit: { type: :integer, required: false, description: "Maximum number of results to return (default 10)" }
+      }.freeze
+      RISK_LEVEL = :read
+      REQUIRES_CONFIRMATION = false
+
+      # @param project_root [String]
+      # @param memory_search [Memory::Search] injected search instance
+      def initialize(project_root:, memory_search: nil)
+        super(project_root: project_root)
+        @memory_search = memory_search
+      end
+
+      # @param query [String]
+      # @param tier [String, nil]
+      # @param category [String, nil]
+      # @param limit [Integer, nil]
+      # @return [String] formatted search results
+      def execute(query:, tier: nil, category: nil, limit: 10)
+        search = @memory_search || resolve_memory_search
+        results = search.search(query, tier: tier, category: category, limit: limit.to_i)
+
+        return "No memories found for query: #{query}" if results.empty?
+
+        format_results(results)
+      end
+
+      private
+
+      # Formats an array of MemoryRecord into a human-readable string.
+      #
+      # @param records [Array<Memory::MemoryRecord>]
+      # @return [String]
+      def format_results(records)
+        lines = ["Found #{records.size} memor#{records.size == 1 ? 'y' : 'ies'}:\n"]
+
+        records.each_with_index do |record, idx|
+          lines << "--- Memory #{idx + 1} ---"
+          lines << "ID: #{record.id}"
+          lines << "Tier: #{record.tier} | Category: #{record.category || 'none'}"
+          lines << "Relevance: #{format('%.2f', record.relevance_score)} | Accessed: #{record.access_count} times"
+          lines << "Created: #{record.created_at}"
+          lines << ""
+          lines << record.content
+          lines << ""
+        end
+
+        lines.join("\n")
+      end
+
+      # Lazily resolves a Memory::Search instance from the project root.
+      #
+      # @return [Memory::Search]
+      def resolve_memory_search
+        db = DB::Connection.instance
+        Memory::Search.new(db, project_path: project_root)
+      end
+    end
+
+    Registry.register(MemorySearch)
+  end
+end

data/lib/rubyn_code/tools/memory_write.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "registry"
+
+module RubynCode
+  module Tools
+    class MemoryWrite < Base
+      TOOL_NAME = "memory_write"
+      DESCRIPTION = "Writes a new memory to the project memory store. " \
+                    "Use this to persist code patterns, user preferences, project conventions, " \
+                    "error resolutions, or architectural decisions for future reference."
+      PARAMETERS = {
+        content: { type: :string, required: true, description: "The memory content to store" },
+        tier: { type: :string, required: false, description: "Memory retention tier: short, medium (default), or long" },
+        category: { type: :string, required: false, description: "Category: code_pattern, user_preference, project_convention, error_resolution, or decision" }
+      }.freeze
+      RISK_LEVEL = :read  # Memory is internal — no user approval needed
+
+      # @param project_root [String]
+      # @param memory_store [Memory::Store] injected store instance
+      def initialize(project_root:, memory_store: nil)
+        super(project_root: project_root)
+        @memory_store = memory_store
+      end
+
+      # @param content [String]
+      # @param tier [String] defaults to "medium"
+      # @param category [String, nil]
+      # @return [String] confirmation message
+      def execute(content:, tier: "medium", category: nil)
+        store = @memory_store || resolve_memory_store
+        record = store.write(content: content, tier: tier, category: category)
+
+        "Memory saved (ID: #{record.id}, tier: #{record.tier}" \
+          "#{record.category ? ", category: #{record.category}" : ''})."
+      end
+
+      private
+
+      # Lazily resolves a Memory::Store instance from the project root.
+      #
+      # @return [Memory::Store]
+      def resolve_memory_store
+        db = DB::Connection.instance
+        Memory::Store.new(db, project_path: project_root)
+      end
+    end
+
+    Registry.register(MemoryWrite)
+  end
+end

data/lib/rubyn_code/tools/rails_generate.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "open3"
+require_relative "base"
+require_relative "registry"
+
+module RubynCode
+  module Tools
+    class RailsGenerate < Base
+      TOOL_NAME = "rails_generate"
+      DESCRIPTION = "Runs a Rails generator command. Validates that the project is a Rails application."
+      PARAMETERS = {
+        generator: { type: :string, required: true, description: "Generator name (e.g. 'model', 'controller', 'migration')" },
+        args: { type: :string, required: true, description: "Arguments for the generator (e.g. 'User name:string email:string')" }
+      }.freeze
+      RISK_LEVEL = :execute
+      REQUIRES_CONFIRMATION = false
+
+      def execute(generator:, args:)
+        validate_rails_project!
+
+        command = "bundle exec rails generate #{generator} #{args}"
+        stdout, stderr, status = Open3.capture3(command, chdir: project_root)
+
+        build_output(stdout, stderr, status)
+      end
+
+      private
+
+      def validate_rails_project!
+        gemfile_path = File.join(project_root, "Gemfile")
+
+        unless File.exist?(gemfile_path)
+          raise Error, "No Gemfile found. This does not appear to be a Ruby project."
+        end
+
+        gemfile_content = File.read(gemfile_path)
+        unless gemfile_content.match?(/['"]rails['"]/)
+          raise Error, "Gemfile does not include Rails. This does not appear to be a Rails project."
+        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(RailsGenerate)
+  end
+end