rails-ai-context 5.32.2 → 5.34.0

data/lib/rails_ai_context/gem_lock.rb

@@ -17,7 +17,9 @@ module RailsAiContext
   module GemLock
     MAX_SIZE = 5 * 1024 * 1024
     SPEC_LINE = /\A {4}(\S+) \(([^)]+)\)\s*\z/
-    DEPENDENCY_LINE = /\A {2}(\S+?)!?(?: \(.*\))?\s*\z/
+    SPEC_DEPENDENCY_LINE = /\A {6}(\S+)/
+    # Bundler puts the "!" of a gem from its own source after the requirement: "sidekiq-pro (= 8.0.3)!".
+    DEPENDENCY_LINE = /\A {2}(\S+?)!?(?: \(.*\))?!?\s*\z/
     # Bundler writes a non-CRuby engine after the version: "ruby 3.1.4p0 (jruby 9.4.8.0)".
     RUBY_LINE = /\A\s+ruby (\S+)(?: \((\S+) ([^)]+)\))?/
     REMOTE_LINE = /\A {2}remote: (.+?)\s*\z/
@@ -44,8 +46,9 @@ module RailsAiContext
       attr_reader :gemfile_gems
 
       def initialize(versions, ruby_versions: {}, ruby_engine: nil, reason: nil, absent: false, direct: nil, path_remotes: [],
-                     outside_gemfile: nil, no_repo: false, gemfile_gems: nil)
+                     outside_gemfile: nil, no_repo: false, gemfile_gems: nil, sources: {})
         @versions = versions
+        @sources = sources
         @gemfile_gems = gemfile_gems
         @outside_gemfile = outside_gemfile
         @no_repo = no_repo
@@ -89,6 +92,11 @@ module RailsAiContext
         @versions.key?(name.to_s)
       end
 
+      # Where the lockfile takes a gem from: [:gem] (a rubygems source), [:path, remote] or [:git]; nil when unlocked.
+      def source(name)
+        @sources[name.to_s]
+      end
+
       def version(name)
         @versions[name.to_s]
       end
@@ -154,6 +162,18 @@ module RailsAiContext
       end
     end
 
+    # The lock of a Gemfile named outright, as BUNDLE_GEMFILE names a dual
+    # boot's Gemfile.next. Nil with no lockfile beside it.
+    def for_gemfile(gemfile, root)
+      gemfile = File.expand_path(gemfile.to_s)
+      dir = File.dirname(gemfile)
+      lockfile = File.basename(gemfile) == "gems.rb" ? File.join(dir, "gems.locked") : "#{gemfile}.lock"
+      return nil unless File.file?(lockfile)
+
+      parse(Bundle.new(lockfile: lockfile, gemfile: gemfile, lock_label: File.basename(lockfile), gemfile_label: File.basename(gemfile),
+                       dir: dir, trusted: dir, outside: nil, no_repo: false), root.to_s)
+    end
+
     # The app's own Gemfile and lockfile, or, with no lockfile of its own, the
     # bundle config/boot.rb points Bundler at (an engine's test/dummy).
     def bundle(root)
@@ -187,14 +207,20 @@ module RailsAiContext
     end
     private_class_method :boot_bundle
 
-    # The BUNDLE_GEMFILE config/boot.rb sets, when it is outside the app root.
+    # The BUNDLE_GEMFILE config/boot.rb sets, when it is outside the app root:
+    # the Gemfile the app boots against when nothing else names one, which a
+    # caller may name whether or not it is in a repository this reads.
     def boot_gemfile(root)
       real_root = File.realpath(root)
       real = File.realpath(File.join(real_root, "config/boot.rb"))
       return nil unless SafePath.contained?(real, real_root)
 
-      result = ruby_parse(real) or return nil
-      relative, anchor = Introspectors::AstWalk.each(result.value).lazy.filter_map { |node| bundle_gemfile_path(node) }.first
+      relative, anchor = if loaded?
+        result = ruby_parse(real) or return nil
+        Introspectors::AstWalk.each(result.value).lazy.filter_map { |node| bundle_gemfile_path(node) }.first
+      else
+        Preboot.bundle_gemfile_path(Preboot.tree(real))
+      end
       return nil unless relative
 
       # Relative to __FILE__ the path starts from boot.rb itself, one level below __dir__.
@@ -203,7 +229,6 @@ module RailsAiContext
     rescue SystemCallError
       nil
     end
-    private_class_method :boot_gemfile
 
     # `ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)`, the line `rails new`
     # and `rails plugin new` write, with `=` or `__FILE__` as older templates do.
@@ -272,13 +297,18 @@ module RailsAiContext
       in_specs = false
       in_dependencies = false
       in_path = false
+      in_git = false
       path_remotes = []
+      path_dependencies = {}
+      spec_name = nil
+      sources = {}
       specs_section = false
       content.each_line do |line|
         if line.match?(/\A\S/)
           in_specs = false
           in_dependencies = line.start_with?("DEPENDENCIES")
           in_path = line.strip == "PATH"
+          in_git = line.strip == "GIT"
         elsif in_path && (match = line.match(REMOTE_LINE))
           path_remotes << match[1].strip
         elsif in_dependencies && (match = line.match(DEPENDENCY_LINE))
@@ -291,6 +321,10 @@ module RailsAiContext
           # per platform. The text before the first hyphen is the version; a
           # prerelease tag ("1.70.0-beta1") is dropped along with the platform.
           versions[match[1]] ||= match[2].split("-", 2).first
+          spec_name = match[1]
+          sources[match[1]] ||= if in_path then [ :path, path_remotes.last ] elsif in_git then [ :git ] else [ :gem ] end
+        elsif in_specs && in_path && spec_name && (match = line.match(SPEC_DEPENDENCY_LINE))
+          (path_dependencies[spec_name] ||= []) << match[1]
         elsif (match = line.match(RUBY_LINE)) && match[1].match?(PLAIN_VERSION)
           ruby_version = [ match[1], engine_name(match[2], match[3]) ]
         end
@@ -300,8 +334,11 @@ module RailsAiContext
       # and answering it as an app with no gems denies every gem it holds.
       return Spec.new({}, reason: "#{File.basename(path)} has no specs section") unless specs_section
 
+      # A gemspec or `path:` gem the Gemfile names brings its runtime dependencies in as the Gemfile's own, as Bundler resolves them.
+      path_dependencies.each { |name, deps| direct.merge(deps) if direct.include?(name) }
       facts = gemfile(bundle)
-      Spec.new(versions, **declared_ruby(ruby_version, root, bundle, facts), direct: direct, path_remotes: path_remotes)
+      Spec.new(versions, **declared_ruby(ruby_version, root, bundle, facts), direct: direct, path_remotes: path_remotes,
+               sources: sources)
     end
     private_class_method :parse
 
@@ -320,17 +357,14 @@ module RailsAiContext
     def gemfile_entries(bundle)
       return Introspectors::GemfileGems.read_bundle(bundle) if loaded?
 
-      result = ruby_parse(bundle.gemfile) or return nil
-      Introspectors::AstWalk.each(result.value).filter_map do |node|
-        next unless node.is_a?(Prism::CallNode) && node.receiver.nil?
-
-        args = node.arguments&.arguments || []
-        case node.name
-        when :ruby
-          options = args.grep(Prism::KeywordHashNode).flat_map(&:elements).grep(Prism::AssocNode).to_h { |pair| [ literal(pair.key), literal(pair.value) ] }
-          { type: :ruby, version: literal(args.first), engine: options["engine"], engine_version: options["engine_version"] }
-        when :gem then args.first.is_a?(Prism::StringNode) ? { type: :gem, name: args.first.unescaped } : { type: :unknown_gems }
-        when :gemspec, :eval_gemfile then { type: :unknown_gems }
+      tree = Preboot.tree(bundle.gemfile) or return nil
+      Preboot.calls(tree).filter_map do |name, args|
+        case name
+        when "ruby"
+          options = Preboot.options(args)
+          { type: :ruby, version: Preboot.literal(args.first), engine: options["engine"], engine_version: options["engine_version"] }
+        when "gem" then (gem = Preboot.string(args.first)) ? { type: :gem, name: gem } : { type: :unknown_gems }
+        when "gemspec", "eval_gemfile" then { type: :unknown_gems }
         end
       end
     end
@@ -341,21 +375,146 @@ module RailsAiContext
     end
     private_class_method :loaded?
 
-    # AstCache once the gem is loaded; before the boot Prism alone, as AstCache's
-    # concurrent-ruby would load ahead of the app's bundle.
+    # Once the gem is loaded; before that, Preboot reads the file.
     def ruby_parse(path)
-      return nil unless path
-      return AstCache.parse(File.realpath(path)) if loaded?
+      return nil unless path && loaded?
 
-      require "prism"
-      require_relative "introspectors/ast_walk"
-      content = SafeFile.read(path, max_size: MAX_SIZE)
-      content && Prism.parse(content)
-    rescue SystemCallError, ArgumentError, LoadError
+      AstCache.parse(File.realpath(path))
+    rescue SystemCallError, ArgumentError
       nil
     end
     private_class_method :ruby_parse
 
+    # Before the boot the Gemfile and config/boot.rb are read with Ripper,
+    # which ships inside Ruby. Prism is a gem the app's bundle locks (every
+    # Rails 8 app's does), so ours, loaded first, had the app's copy load over
+    # it at the boot: "already initialized constant", then a mixed parser.
+    # AstCache would bring concurrent-ruby in ahead of the bundle the same way.
+    module Preboot
+      module_function
+
+      def tree(path)
+        return nil unless path
+
+        require "ripper"
+        content = SafeFile.read(path, max_size: MAX_SIZE)
+        content && Ripper.sexp(content)
+      rescue SystemCallError, ArgumentError, LoadError
+        nil
+      end
+
+      # Every node, parent first: a Ripper node is an Array led by its type.
+      def each(node, &block)
+        return unless node.is_a?(Array)
+
+        yield node if node.first.is_a?(Symbol)
+        node.each { |child| each(child, &block) }
+      end
+
+      # [name, arguments] of each call with no receiver: `gem "x"`, `gem("x")`, a bare `gemspec`.
+      def calls(tree)
+        found = []
+        each(tree) do |node|
+          case node.first
+          when :command then found << [ ident(node[1]), arguments(node[2]) ]
+          when :method_add_arg then found << [ ident(node[1][1]), arguments(node[2]) ] if node[1].is_a?(Array) && node[1].first == :fcall
+          when :vcall then found << [ ident(node[1]), [] ]
+          end
+        end
+        found
+      end
+
+      def ident(node)
+        node[1] if node.is_a?(Array) && node.first == :@ident
+      end
+
+      def arguments(node)
+        return [] unless node.is_a?(Array)
+
+        case node.first
+        when :arg_paren then arguments(node[1])
+        when :args_add_block then node[1].is_a?(Array) ? node[1] : []
+        else []
+        end
+      end
+
+      # A string as written, nil for anything computed. Escapes stay as
+      # written: no gem name, version or path the Gemfile needs holds one.
+      def string(node)
+        return nil unless node.is_a?(Array) && node.first == :string_literal
+
+        parts = node[1].is_a?(Array) ? node[1].drop(1) : []
+        return "" if parts.empty?
+
+        parts.first[1] if parts.one? && parts.first.is_a?(Array) && parts.first.first == :@tstring_content
+      end
+
+      def literal(node)
+        return string(node) unless node.is_a?(Array) && node.first == :symbol_literal
+
+        symbol = node[1]
+        symbol[1][1] if symbol.is_a?(Array) && symbol.first == :symbol && symbol[1].is_a?(Array)
+      end
+
+      # `engine: "jruby"`, `"engine" => "jruby"` and `:engine => "jruby"` alike.
+      def options(args)
+        args.select { |arg| arg.is_a?(Array) && arg.first == :bare_assoc_hash }.flat_map { |hash| Array(hash[1]) }
+            .select { |pair| pair.is_a?(Array) && pair.first == :assoc_new }
+            .to_h { |pair| [ key(pair[1]), literal(pair[2]) ] }
+      end
+
+      def key(node)
+        node.is_a?(Array) && node.first == :@label ? node[1].delete_suffix(":") : literal(node)
+      end
+
+      # [path, :file or :dir] from config/boot.rb's
+      # `ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)`, `=` and `__FILE__` alike.
+      def bundle_gemfile_path(tree)
+        each(tree) do |node|
+          value = case node.first
+          when :opassign then node[3] if env_field?(node[1]) && node[2].is_a?(Array) && node[2][1] == "||="
+          when :assign then node[2] if env_field?(node[1])
+          end
+          found = value && expand_path(value)
+          return found if found
+        end
+        nil
+      end
+
+      def env_field?(node)
+        return false unless node.is_a?(Array) && node.first == :aref_field
+
+        receiver = node[1]
+        args = arguments(node[2])
+        receiver.is_a?(Array) && receiver.first == :var_ref && receiver[1].is_a?(Array) && receiver[1][1] == "ENV" &&
+          args.one? && string(args.first) == "BUNDLE_GEMFILE"
+      end
+
+      def expand_path(node)
+        return nil unless node.is_a?(Array) && node.first == :method_add_arg
+
+        call = node[1]
+        return nil unless call.is_a?(Array) && call.first == :call && ident(call[3]) == "expand_path" &&
+                          call[1].is_a?(Array) && call[1].first == :var_ref && call[1][1].is_a?(Array) && call[1][1][1] == "File"
+
+        path, anchor = args = arguments(node[2])
+        relative = string(path)
+        return nil unless relative && args.size == 2
+
+        if anchor.is_a?(Array) && anchor.first == :var_ref && anchor[1].is_a?(Array) && anchor[1][1] == "__FILE__" then [ relative, :file ]
+        elsif dir_call?(anchor) then [ relative, :dir ]
+        end
+      end
+
+      def dir_call?(node)
+        return false unless node.is_a?(Array)
+
+        (node.first == :vcall && ident(node[1]) == "__dir__") ||
+          (node.first == :method_add_arg && node[1].is_a?(Array) && node[1].first == :fcall && ident(node[1][1]) == "__dir__")
+      end
+    end
+    private_constant :Preboot
+
     # A requirement such as `ruby ">= 3.3.0"` names a range, not a version, so it is left unanswered.
     def gemfile_ruby(entry)
       version = entry[:version]

data/lib/rails_ai_context/git_ignore.rb

@@ -101,6 +101,28 @@ module RailsAiContext
         nil
       end
 
+      # The directory links ripgrep would meet under `start`, in its order, past
+      # the same ignore files and `skip`; it enters none of them.
+      def dir_links(start = @root, skip: nil)
+        Dir.children(start).sort.flat_map do |name|
+          next [] if name.start_with?(".")
+
+          path = File.join(start, name)
+          stat = File.lstat(path)
+          next [] unless stat.symlink? || stat.directory?
+
+          relative = path.delete_prefix("#{@root}/")
+          next [] if skip&.call(relative, true) || verdict(path, true) == :ignore
+          next dir_links(path, skip: skip) unless stat.symlink?
+
+          File.directory?(path) ? [ path ] : []
+        rescue SystemCallError
+          []
+        end
+      rescue SystemCallError
+        []
+      end
+
       private
 
       def dir_ignored?(path)

data/lib/rails_ai_context/install/ai_tool.rb

@@ -16,6 +16,17 @@ module RailsAiContext
     #
     # rule_files names what the gem writes inside rules_dir. The directory is shared with
     # rules the user writes by hand, so cleanup removes these names and nothing else.
+    #
+    # mcp_config[:folder_variable] is how the tool's config names the folder it sits in, where
+    # it has a name for it: a workspace entry's app path starts from that name. The others get
+    # a bare relative path, which they resolve against the folder they were started in.
+    #
+    # mcp_config[:client] is the program that reads the config, and [:jsonc] whether it reads
+    # JSONC - comments and trailing commas - or refuses them, as JSON does. VS Code reads
+    # .vscode/mcp.json as a standalone configuration file, with its JSONC parser and trailing
+    # commas allowed; OpenCode reads opencode.json with jsonc-parser, trailing commas allowed.
+    # Claude Code reads .mcp.json with JSON.parse. Cursor's is held to JSON as well, the form
+    # every reader takes: nothing shows its reader takes JSONC.
     AiTool = Struct.new(:number, :key, :name, :files, :context_paths, :rules_dir, :rule_files, :mcp_config,
                         :legacy_paths, :owned_dir, keyword_init: true)
 
@@ -27,7 +38,7 @@ module RailsAiContext
           context_paths: %w[CLAUDE.md .claude/rules],
           rules_dir: ".claude/rules",
           rule_files: %w[rails-context.md rails-schema.md rails-models.md rails-mcp-tools.md rails-components.md],
-          mcp_config: { path: ".mcp.json", root_key: "mcpServers", format: :mcp_json },
+          mcp_config: { path: ".mcp.json", root_key: "mcpServers", format: :mcp_json, client: "Claude Code", jsonc: false },
           legacy_paths: [ ".claude/rules/rails-ui-patterns.md", ".claude/rules/rails-accessibility.md" ],
           owned_dir: ".claude"
         ),
@@ -37,7 +48,8 @@ module RailsAiContext
           context_paths: %w[.cursor/rules .cursorrules],
           rules_dir: ".cursor/rules",
           rule_files: %w[rails-project.mdc rails-models.mdc rails-controllers.mdc rails-mcp-tools.mdc],
-          mcp_config: { path: ".cursor/mcp.json", root_key: "mcpServers", format: :mcp_json },
+          mcp_config: { path: ".cursor/mcp.json", root_key: "mcpServers", format: :mcp_json,
+                        folder_variable: "${workspaceFolder}", client: "Cursor", jsonc: false },
           legacy_paths: [ ".cursor/rules/rails-ui-patterns.mdc" ],
           owned_dir: ".cursor"
         ),
@@ -50,26 +62,34 @@ module RailsAiContext
             rails-context.instructions.md rails-models.instructions.md
             rails-controllers.instructions.md rails-mcp-tools.instructions.md
           ],
-          mcp_config: { path: ".vscode/mcp.json", root_key: "servers", format: :vscode_json },
+          mcp_config: { path: ".vscode/mcp.json", root_key: "servers", format: :vscode_json,
+                        folder_variable: "${workspaceFolder}", client: "VS Code", jsonc: true },
           legacy_paths: [ ".github/instructions/rails-ui-patterns.instructions.md" ]
         ),
         new(
           number: "4", key: :opencode, name: "OpenCode",
           files: "AGENTS.md",
           context_paths: %w[AGENTS.md app/models/AGENTS.md app/controllers/AGENTS.md],
-          mcp_config: { path: "opencode.json", root_key: "mcp", format: :opencode_json },
+          mcp_config: { path: "opencode.json", root_key: "mcp", format: :opencode_json, client: "OpenCode", jsonc: true },
           legacy_paths: []
         ),
         new(
           number: "5", key: :codex, name: "Codex CLI",
           files: "AGENTS.md + .codex/config.toml",
           context_paths: %w[AGENTS.md app/models/AGENTS.md app/controllers/AGENTS.md],
-          mcp_config: { path: ".codex/config.toml", root_key: nil, format: :codex_toml },
+          mcp_config: { path: ".codex/config.toml", root_key: nil, format: :codex_toml, client: "Codex CLI" },
           legacy_paths: [],
           owned_dir: ".codex"
         )
       ].freeze
 
+      # What a summary lists for the tool. `files` names Codex CLI's MCP
+      # config beside its context files, and a CLI-mode or per-app summary
+      # writes no MCP config, so it leaves that part out.
+      def files_label(mcp: true)
+        mcp ? files : context_files
+      end
+
       class << self
         def all
           ALL
@@ -88,6 +108,12 @@ module RailsAiContext
           ALL.flat_map { |tool| tool.legacy_paths.map { |path| { path: path, ai_tool: tool.key } } }
         end
       end
+
+      # What `rails ai:context:<key>` writes for the tool: its files without
+      # its MCP config, which only the install writes.
+      def context_files
+        files.split(" + ").reject { |file| file == mcp_config[:path] }.join(" + ")
+      end
     end
   end
 end

data/lib/rails_ai_context/install/cleanup.rb

@@ -49,9 +49,30 @@ module RailsAiContext
           end
         end
 
+        prune_emptied(outcome, root)
         outcome
       end
 
+      # A tool's dot-directory (.cursor/, .github/) that the removal emptied
+      # goes too, and is reported like any other path. One that holds
+      # anything else stays, and a directory outside the dot-directories -
+      # app/models, emptied of its AGENTS.md - is never removed.
+      def prune_emptied(outcome, root)
+        outcome[:removed].map { |path| File.dirname(path.delete_suffix("/")) }.uniq.each do |dir|
+          while dir.start_with?(".") && dir != "."
+            full = File.join(root.to_s, dir)
+            break unless File.directory?(full) && !File.symlink?(full) && Dir.empty?(full)
+
+            Dir.rmdir(full)
+            outcome[:removed] << "#{dir}/"
+            dir = File.dirname(dir)
+          end
+        rescue SystemCallError
+          next
+        end
+      end
+      private_class_method :prune_emptied
+
       # A symlink is somebody's own arrangement, and writing through one edits
       # a file this run was not asked about.
       def remove_rule_files(tool, dir, root, outcome)