rails-ai-context 4.2.2 → 4.3.0

data/lib/rails_ai_context/tools/review_changes.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module RailsAiContext
+  module Tools
+    class ReviewChanges < BaseTool
+      tool_name "rails_review_changes"
+      description "PR/commit review context: shows changed files with relevant schema/model/route context per file, " \
+        "detects warnings (missing indexes, removed validations, changed associations, new routes without tests). " \
+        "Use when: reviewing changes before merging, understanding what a commit changed and its impact. " \
+        "Key params: ref (default 'HEAD' for uncommitted, or 'main', 'HEAD~3', commit SHA)."
+
+      input_schema(
+        properties: {
+          ref: {
+            type: "string",
+            description: "Git ref to diff against. 'HEAD' = uncommitted changes (default). 'main' = diff from main. 'HEAD~3' = last 3 commits. 'abc123' = specific commit."
+          },
+          files: {
+            type: "array",
+            items: { type: "string" },
+            description: "Filter to specific files (relative to Rails root). Omit to review all changed files."
+          }
+        }
+      )
+
+      annotations(read_only_hint: true, destructive_hint: false, idempotent_hint: false, open_world_hint: true)
+
+      MAX_DIFF_LINES_PER_FILE = 60
+
+      def self.call(ref: "HEAD", files: nil, server_context: nil)
+        root = Rails.root.to_s
+
+        # Verify git is available
+        _, status = Open3.capture2("git", "rev-parse", "--git-dir", chdir: root)
+        unless status.success?
+          return text_response("Not a git repository. `rails_review_changes` requires git.")
+        end
+
+        changed = get_changed_files(ref, root)
+        changed = changed.select { |f| files.any? { |filter| f.include?(filter) } } if files&.any?
+
+        if changed.empty?
+          return text_response("No changes found for ref '#{ref}'.#{files ? " Filter: #{files.join(', ')}" : ""}")
+        end
+
+        # Classify files
+        classified = changed.map { |f| { file: f, type: classify_file(f) } }
+
+        # Get commit log
+        commits = get_commit_log(ref, root)
+
+        # Build output
+        lines = [ "# Review: #{ref}", "" ]
+
+        # Summary
+        type_counts = classified.group_by { |c| c[:type] }.transform_values(&:size)
+        summary_parts = type_counts.map { |type, count| "#{count} #{type}" }
+        lines << "**#{changed.size} files changed** (#{summary_parts.join(', ')})"
+        lines << ""
+
+        if commits
+          lines << "## Commits"
+          lines << "```"
+          lines << commits
+          lines << "```"
+          lines << ""
+        end
+
+        # Detect warnings
+        warnings = detect_warnings(classified, root, ref)
+        if warnings.any?
+          lines << "## Warnings"
+          warnings.each { |w| lines << "- #{w}" }
+          lines << ""
+        end
+
+        # File-by-file context
+        lines << "## File-by-File Context"
+        lines << ""
+
+        classified.each do |entry|
+          file_lines = gather_file_context(entry[:file], entry[:type], root, ref)
+          lines.concat(file_lines)
+        end
+
+        # Next steps
+        rb_files = classified.select { |c| c[:file].end_with?(".rb") }.map { |c| c[:file] }
+        if rb_files.any?
+          file_list = rb_files.first(10).map { |f| "\"#{f}\"" }.join(", ")
+          lines << "_Next: `rails_validate(files:[#{file_list}], level:\"rails\")` to validate all changes._"
+        end
+
+        text_response(lines.join("\n"))
+      rescue => e
+        text_response("Review error: #{e.message}")
+      end
+
+      class << self
+        private
+
+        def get_changed_files(ref, root)
+          if ref == "HEAD"
+            staged, _ = Open3.capture2("git", "diff", "--cached", "--name-only", chdir: root)
+            unstaged, _ = Open3.capture2("git", "diff", "--name-only", chdir: root)
+            untracked, _ = Open3.capture2("git", "ls-files", "--others", "--exclude-standard", chdir: root)
+            (staged.lines + unstaged.lines + untracked.lines).map(&:strip).reject(&:empty?).uniq
+          else
+            # Try three-dot (since divergence from ref)
+            output, status = Open3.capture2("git", "diff", "--name-only", "#{ref}...HEAD", chdir: root)
+            unless status.success?
+              # Fall back to two-dot
+              output, status = Open3.capture2("git", "diff", "--name-only", "#{ref}..HEAD", chdir: root)
+              unless status.success?
+                # Fall back to single ref diff
+                output, _ = Open3.capture2("git", "diff", "--name-only", ref, chdir: root)
+              end
+            end
+            output.lines.map(&:strip).reject(&:empty?).uniq
+          end
+        end
+
+        def get_commit_log(ref, root)
+          return nil if ref == "HEAD"
+          output, status = Open3.capture2("git", "log", "--oneline", "-10", "#{ref}..HEAD", chdir: root)
+          return nil unless status.success? && !output.strip.empty?
+          output.strip
+        end
+
+        def classify_file(path)
+          case path
+          when %r{\Aapp/models/}          then :model
+          when %r{\Aapp/controllers/}     then :controller
+          when %r{\Adb/migrate/}          then :migration
+          when %r{\Aapp/views/}           then :view
+          when %r{\Aconfig/routes}        then :routes
+          when %r{\A(spec|test)/}         then :test
+          when %r{\Aapp/services/}        then :service
+          when %r{\Aapp/jobs/}            then :job
+          when %r{\Aapp/javascript/}      then :javascript
+          when %r{\Aconfig/}              then :config
+          else :other
+          end
+        end
+
+        def gather_file_context(file, type, root, ref) # rubocop:disable Metrics
+          lines = [ "### #{file} (#{type})", "" ]
+
+          # Show diff summary
+          diff = get_file_diff(file, root, ref)
+          if diff
+            diff_lines = diff.lines
+            added = diff_lines.count { |l| l.start_with?("+") && !l.start_with?("+++") }
+            removed = diff_lines.count { |l| l.start_with?("-") && !l.start_with?("---") }
+            lines << "+#{added} / -#{removed} lines"
+
+            # Show truncated diff
+            content_lines = diff_lines.reject { |l| l.start_with?("diff ", "index ", "--- ", "+++ ") }
+            if content_lines.size > MAX_DIFF_LINES_PER_FILE
+              lines << "```diff"
+              lines.concat(content_lines.first(MAX_DIFF_LINES_PER_FILE).map(&:rstrip))
+              lines << "# ... #{content_lines.size - MAX_DIFF_LINES_PER_FILE} more lines"
+              lines << "```"
+            elsif content_lines.any?
+              lines << "```diff"
+              lines.concat(content_lines.map(&:rstrip))
+              lines << "```"
+            end
+          end
+
+          # Pull relevant context per file type
+          case type
+          when :model
+            model_name = File.basename(file, ".rb").camelize
+            begin
+              result = GetModelDetails.call(model: model_name, detail: "standard")
+              text = result.content.first[:text]
+              lines << "" << "**Model context:** #{model_name}" unless text.include?("not found")
+            rescue; end
+
+          when :controller
+            ctrl_name = File.basename(file, ".rb").camelize
+            snake = ctrl_name.underscore.delete_suffix("_controller")
+            begin
+              result = GetRoutes.call(controller: snake, detail: "summary")
+              text = result.content.first[:text]
+              lines << "" << "**Routes:**" << text unless text.include?("not found") || text.include?("No routes")
+            rescue; end
+
+          when :migration
+            # Parse migration for table/column info
+            full_path = File.join(root, file)
+            if File.exist?(full_path)
+              source = File.read(full_path, encoding: "UTF-8", invalid: :replace, undef: :replace) rescue nil
+              if source
+                tables = source.scan(/(?:create_table|add_column|remove_column|rename_column|add_index|add_reference)\s+:(\w+)/).flatten.uniq
+                if tables.any?
+                  lines << "" << "**Affects tables:** #{tables.join(', ')}"
+                  tables.first(2).each do |t|
+                    begin
+                      result = GetSchema.call(table: t, detail: "summary")
+                      text = result.content.first[:text]
+                      lines << "  #{t}: #{text.lines.first&.strip}" unless text.include?("not found")
+                    rescue; end
+                  end
+                end
+              end
+            end
+
+          when :routes
+            begin
+              result = GetRoutes.call(detail: "summary")
+              lines << "" << "**Current routes:** #{result.content.first[:text].lines.first&.strip}"
+            rescue; end
+          end
+
+          lines << ""
+          lines
+        end
+
+        def get_file_diff(file, root, ref)
+          if ref == "HEAD"
+            output, status = Open3.capture2("git", "diff", "--", file, chdir: root)
+            if !status.success? || output.strip.empty?
+              output, status = Open3.capture2("git", "diff", "--cached", "--", file, chdir: root)
+            end
+          else
+            output, status = Open3.capture2("git", "diff", ref, "--", file, chdir: root)
+          end
+          status.success? && !output.strip.empty? ? output : nil
+        end
+
+        def detect_warnings(classified, root, ref) # rubocop:disable Metrics
+          warnings = []
+
+          migration_files = classified.select { |c| c[:type] == :migration }
+          model_files = classified.select { |c| c[:type] == :model }
+          test_files = classified.select { |c| c[:type] == :test }
+          controller_files = classified.select { |c| c[:type] == :controller }
+
+          # Check migrations for missing indexes on foreign key columns
+          migration_files.each do |entry|
+            full_path = File.join(root, entry[:file])
+            next unless File.exist?(full_path)
+            source = File.read(full_path, encoding: "UTF-8", invalid: :replace, undef: :replace) rescue next
+
+            # New columns ending in _id without add_index
+            source.scan(/add_column\s+:\w+,\s+:(\w+_id)/).flatten.each do |col|
+              unless source.include?("add_index") && source.include?(col)
+                warnings << "**Missing index**: `#{entry[:file]}` adds `#{col}` without an index"
+              end
+            end
+
+            # add_reference without index: false check
+            source.scan(/add_reference\s+:(\w+),\s+:(\w+)/).each do |_table, ref_name|
+              if source.include?("index: false")
+                warnings << "**Disabled index**: `#{entry[:file]}` adds reference `#{ref_name}` with `index: false`"
+              end
+            end
+          end
+
+          # Check model diffs for removed validations
+          model_files.each do |entry|
+            diff = get_file_diff(entry[:file], root, ref)
+            next unless diff
+            removed_validations = diff.lines.select { |l| l.start_with?("-") && l.match?(/validates?\s/) }
+            removed_validations.each do |line|
+              warnings << "**Removed validation**: `#{entry[:file]}` — `#{line.strip[1..].strip}`"
+            end
+          end
+
+          # Check for controller changes without test changes
+          changed_ctrls = controller_files.map { |c| File.basename(c[:file], ".rb") }
+          changed_tests = test_files.map { |t| File.basename(t[:file], ".rb") }
+          changed_ctrls.each do |ctrl|
+            test_name = ctrl.sub("_controller", "_controller_test")
+            spec_name = ctrl.sub("_controller", "_controller_spec")
+            request_name = ctrl.sub("_controller", "_spec")
+            unless changed_tests.any? { |t| t == test_name || t == spec_name || t == request_name || t.include?(ctrl.delete_suffix("_controller")) }
+              warnings << "**No test changes**: `#{ctrl}.rb` was modified but no corresponding test file was changed"
+            end
+          end
+
+          warnings
+        end
+      end
+    end
+  end
+end

data/lib/rails_ai_context/tools/search_code.rb

@@ -180,7 +180,8 @@ module RailsAiContext
       end
 
       private_class_method def self.ripgrep_available?
-        @rg_available ||= system("which rg > /dev/null 2>&1")
+        return @rg_available unless @rg_available.nil?
+        @rg_available = system("which rg > /dev/null 2>&1")
       end
 
       private_class_method def self.search_with_ripgrep(pattern, search_path, file_type, max_results, root, ctx_lines = 0, exclude_tests: false)
@@ -462,8 +463,10 @@ module RailsAiContext
       private_class_method def self.extract_controller_actions_from_matches(matches)
         actions = []
         matches.each do |m|
-          # Look for the method name from indentation context
-          actions << $1 if m[:content].match?(/\b(create|index|show|new|edit|update|destroy|[a-z_]+)\b/)
+          # Match standard RESTful action names from the content
+          if (match = m[:content].match(/\b(index|show|new|create|edit|update|destroy)\b/))
+            actions << match[1]
+          end
         end
         actions.uniq.first(3)
       end

data/lib/rails_ai_context/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsAiContext
-  VERSION = "4.2.2"
+  VERSION = "4.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-ai-context
 version: !ruby/object:Gem::Version
-  version: 4.2.2
+  version: 4.3.0
 platform: ruby
 authors:
 - crisnahine
@@ -170,7 +170,7 @@ dependencies:
 description: |
   rails-ai-context gives AI coding agents a complete mental model of your Rails
   app — not just files, but how schema, models, routes, controllers, views, and
-  conventions connect. 33 live tools (via MCP server or CLI) let agents query
+  conventions connect. 37 live tools (via MCP server or CLI) let agents query
   structure on demand with semantic validation that catches cross-file errors
   (wrong columns, missing partials, broken routes) before code runs.
   Auto-generates context files for Claude Code, Cursor, GitHub Copilot, and
@@ -262,6 +262,8 @@ files:
 - lib/rails_ai_context/tools/analyze_feature.rb
 - lib/rails_ai_context/tools/base_tool.rb
 - lib/rails_ai_context/tools/dependency_graph.rb
+- lib/rails_ai_context/tools/diagnose.rb
+- lib/rails_ai_context/tools/generate_test.rb
 - lib/rails_ai_context/tools/get_callbacks.rb
 - lib/rails_ai_context/tools/get_component_catalog.rb
 - lib/rails_ai_context/tools/get_concern.rb
@@ -286,9 +288,11 @@ files:
 - lib/rails_ai_context/tools/get_turbo_map.rb
 - lib/rails_ai_context/tools/get_view.rb
 - lib/rails_ai_context/tools/migration_advisor.rb
+- lib/rails_ai_context/tools/onboard.rb
 - lib/rails_ai_context/tools/performance_check.rb
 - lib/rails_ai_context/tools/query.rb
 - lib/rails_ai_context/tools/read_logs.rb
+- lib/rails_ai_context/tools/review_changes.rb
 - lib/rails_ai_context/tools/search_code.rb
 - lib/rails_ai_context/tools/search_docs.rb
 - lib/rails_ai_context/tools/security_scan.rb
@@ -311,7 +315,7 @@ post_install_message: |
   rails-ai-context installed! Quick start:
     rails generate rails_ai_context:install
     rails ai:context              # generate context files
-    rails 'ai:tool[schema]'      # run any of the 33 tools from CLI
+    rails 'ai:tool[schema]'      # run any of the 37 tools from CLI
     rails ai:serve                # start MCP server (optional)
 rdoc_options: []
 require_paths:
@@ -329,6 +333,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: Give AI agents a complete mental model of your Rails app — 33 tools via MCP
+summary: Give AI agents a complete mental model of your Rails app — 37 tools via MCP
   or CLI. Zero config.
 test_files: []