rubino-agent 0.3.0

data/lib/rubino/ui/completion_menu.rb

@@ -0,0 +1,321 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+module Rubino
+  module UI
+    # The {BottomComposer}'s /command + @file completion menu: an inline
+    # navigable list rendered in the multi-row live region above the prompt.
+    # Candidates come from the shared CompletionSource. The menu auto-opens as
+    # you type a `/` or `@` token (Reline parity); Tab also opens/accepts, ↑/↓
+    # navigate, Enter accepts, ESC dismisses immediately (and STICKS for the
+    # token) leaving the typed buffer untouched.
+    #
+    # Pure state machine + row formatting: it reads the buffer/cursor the
+    # composer passes in and never prints or takes the render mutex — opening,
+    # navigation and the accept SPLICE are decided here, but the composer
+    # applies the splice to its buffer and owns every redraw.
+    class CompletionMenu
+      # Most candidate rows shown at once (the list scrolls within this window
+      # for longer candidate sets so the prompt is never pushed off-screen).
+      MAX_ROWS = 8
+
+      # @param completion_source [CompletionSource, nil] shared completion
+      #   discovery (slash commands + @file picker). nil ⇒ the menu is inert
+      #   (steering / standalone), so the composer degrades to a plain editor.
+      def initialize(completion_source)
+        @completion = completion_source
+        # Open state: nil when closed, else a Hash with the candidate :items,
+        # the :selected index, the :top of the visible window, the :token span
+        # being completed (so accept can splice the replacement at the cursor)
+        # and the :navigated accept-intent flag.
+        @state = nil
+        # Sticky ESC-dismiss: once the user presses ESC on an open menu, keep
+        # it closed for the CURRENT token instead of re-opening on the next
+        # keystroke. Cleared when the token is cleared / on submit / on accept /
+        # on an explicit Tab, so a fresh token (or a deliberate Tab) reopens.
+        @suppressed = false
+      end
+
+      def open?
+        !@state.nil?
+      end
+
+      # The open menu's candidate items (test/inspection helper), nil when closed.
+      def items
+        @state && @state[:items]
+      end
+
+      # Explicit open (Tab): always clears a sticky ESC-dismiss first — a
+      # deliberate Tab reopens a dismissed menu — then opens for the completion
+      # context under the cursor, if any. Returns the opened state (truthy; the
+      # composer redraws on it), or nil when nothing completes here.
+      def open(buffer, cursor)
+        @suppressed = false
+        ctx = completion_context(buffer, cursor)
+        return unless ctx
+
+        items, start, len = ctx
+        @state = { items: items, selected: 0, top: 0, start: start, token_len: len,
+                   navigated: false }
+      end
+
+      # Open / update / close the menu on every edit and cursor move, matching
+      # the old Reline autocompletion: typing a leading `/` or `@` token
+      # AUTO-opens the dropdown (no Tab needed), refining as the token grows and
+      # closing when it no longer completes. Called from every buffer-edit and
+      # cursor-move path so the list always tracks the token under the cursor.
+      #
+      #   * no token under the cursor → close the menu AND clear the sticky
+      #     ESC-dismiss flag (a fresh token may auto-open again);
+      #   * token present but ESC-dismissed for it → stay closed;
+      #   * token with candidates → OPEN a new menu, or UPDATE an open one
+      #     (preserving the clamped selection); no candidates → close.
+      #
+      # The selected index is preserved (clamped) across an update so refining
+      # the token doesn't jump the highlight back to the top mid-navigation.
+      def auto_update(buffer, cursor)
+        ctx = completion_context(buffer, cursor)
+        if ctx.nil?
+          @state = nil
+          @suppressed = false # token cleared: a fresh token can auto-open
+          return
+        end
+        return if @suppressed # ESC stuck this token/argument closed
+
+        items, start, len = ctx
+        sel = (@state ? @state[:selected] : 0).clamp(0, items.size - 1)
+        @state = { items: items, selected: sel, top: window_top(sel, items.size),
+                   start: start, token_len: len,
+                   navigated: @state ? @state[:navigated] : false }
+      end
+
+      # ↑/↓ within the open menu (routed from the composer's history keys).
+      # Arrowing marks the menu as NAVIGATED — an explicit accept intent, so
+      # Enter on an empty argument token accepts the highlight instead of
+      # submitting the buffer (see #exact_command?).
+      def up
+        @state[:selected] = [@state[:selected] - 1, 0].max
+        navigated_to_selection
+      end
+
+      def down
+        @state[:selected] = [@state[:selected] + 1, @state[:items].size - 1].min
+        navigated_to_selection
+      end
+
+      # Accept the highlighted candidate: returns the splice the composer
+      # applies — [start, token_len, replacement] where the replacement carries
+      # a trailing space (so the next token starts clean, like Reline's append
+      # char) — and closes the menu (clearing the sticky dismiss: accepting
+      # ends this token; a new one can auto-open).
+      def accept_splice
+        choice = @state[:items][@state[:selected]].to_s
+        splice = [@state[:start], @state[:token_len], "#{choice} "]
+        close!
+        splice
+      end
+
+      # True when the buffer is ALREADY an exact, complete command, so Enter
+      # should SUBMIT it rather than accept-and-space (D5/#147). Compares the
+      # TOKEN the menu would splice (not the whole buffer, which never matches
+      # a bare argument candidate — that's what swallowed Enter on a fully
+      # typed `/agents sa_xxx`): submit when the typed token equals a
+      # candidate exactly AND that match is the menu's current selection (or
+      # the only candidate) — so a partial/ambiguous token (e.g. "/re" with
+      # /reasoning + /reset) still accepts the highlight on Enter as before.
+      # An EMPTY argument token (`/agents sa_xxx ` with the verb dropdown
+      # open) also submits — the buffer is already a complete command and
+      # accepting would splice a verb the user never typed — UNLESS the user
+      # explicitly arrow-navigated onto a candidate, which is an accept
+      # intent. Tab-accept is untouched.
+      def exact_command?(buffer)
+        return false unless @state
+
+        typed = Array(buffer.chars[@state[:start], @state[:token_len]]).join
+        return !@state[:navigated] if typed.empty?
+
+        items = @state[:items]
+        return false unless items.include?(typed)
+
+        selected = items[@state[:selected]].to_s
+        items.size == 1 || selected == typed
+      end
+
+      # Close the menu and clear the sticky ESC-dismiss flag (submit / accept):
+      # the next token starts fresh and is free to auto-open again.
+      def close!
+        @state = nil
+        @suppressed = false
+      end
+
+      # Lone-ESC dismiss: close AND STICK for the current token so it doesn't
+      # pop back on the next keystroke. Cleared when the token changes to nil,
+      # on submit/accept, or on an explicit Tab (see #auto_update / #close!).
+      def dismiss!
+        @state = nil
+        @suppressed = true
+      end
+
+      # Teardown hide (composer stop/suspend): close the rows without touching
+      # the sticky dismiss, so a resume mid-token behaves exactly as before.
+      def hide!
+        @state = nil
+      end
+
+      # The rendered menu rows (the slice in view, the selected one marked with
+      # a cyan ❯ and inverse highlight), or [] when no menu is open. House
+      # grammar: a dim aside bar leads each row. Candidates with a registered
+      # description (BuiltIns/custom command one-liners, the /agents subcommand
+      # hints) show it dim in an aligned column next to the name (#39).
+      def rows(cols)
+        return [] unless @state
+
+        items = @state[:items]
+        top   = @state[:top]
+        sel   = @state[:selected]
+        slice = items[top, MAX_ROWS] || []
+        pad   = slice.map { |item| LiveRegion.display_width(item.to_s) }.max.to_i
+        rows = slice.each_with_index.map do |item, i|
+          candidate_row(item, pad, cols, selected: top + i == sel)
+        end
+        rows << pastel.dim("┄ #{sel + 1}/#{items.size} ┄") if items.size > MAX_ROWS
+        rows
+      end
+
+      private
+
+      def navigated_to_selection
+        @state[:top] = window_top(@state[:selected], @state[:items].size)
+        @state[:navigated] = true
+      end
+
+      def candidate_row(item, pad, cols, selected:)
+        row = if selected
+                "#{pastel.cyan("❯")} #{pastel.inverse(" #{item} ")}"
+              else
+                "#{pastel.dim("┊")} #{item}"
+              end
+        desc = description(item, pad, cols)
+        if desc
+          # Align the description column across rows: the inverse highlight
+          # already widens the selected name by 2 (its padding spaces).
+          row += (" " * (pad - LiveRegion.display_width(item.to_s) + (selected ? 0 : 2)))
+          row += pastel.dim(desc)
+        end
+        row
+      end
+
+      # The dim description for a menu candidate, fitted to the row budget so a
+      # long one-liner is right-truncated here instead of the shared row clamp
+      # left-truncating the candidate NAME away. nil when the source has none
+      # (files, skill names) or the row is too narrow to show one usefully.
+      def description(item, pad, cols)
+        return nil unless @completion.respond_to?(:description_for)
+
+        desc = @completion.description_for(item).to_s
+        return nil if desc.empty?
+
+        budget = cols - pad - 6 # glyph + gaps + the one-column scroll guard
+        return nil if budget < 8
+
+        desc.length > budget ? "#{desc[0, budget - 1]}…" : desc
+      end
+
+      # Resolve what to complete at the cursor: returns [items, start, len]
+      # where +items+ are the candidate strings, +start+ the codepoint index
+      # where the splice begins, and +len+ the length of the text the accepted
+      # choice replaces — or nil when nothing completes here.
+      #
+      # Two shapes, in priority order:
+      #   1. COMMAND ARGUMENT — the buffer is `/<cmd> <partial>` and <cmd> has a
+      #      registered argument source (e.g. `/skills ruby` → skill names). The
+      #      partial (possibly empty) is the splice span; this is what lets the
+      #      SAME dropdown pick a skill name as it picks a /command or @file.
+      #   2. LEADING TOKEN — a `/command` or `@file` token under the cursor
+      #      (the original behavior), spliced over the whole token.
+      def completion_context(buffer, cursor)
+        return nil unless @completion
+
+        if (arg = command_arg_context(buffer, cursor))
+          command, partial, start, args = arg
+          items = arg_candidates(command, partial, args)
+          return nil if items.empty?
+
+          return [items, start, partial.chars.length]
+        end
+
+        tok = current_token(buffer, cursor)
+        return nil unless tok
+
+        token, start = tok
+        items = candidates(token)
+        return nil if items.empty?
+
+        [items, start, token.chars.length]
+      end
+
+      # The completion TOKEN under the cursor: the leading run of non-space
+      # chars from the start of the line up to the cursor, when it begins with
+      # / or @. Returns [token, start_index] or nil when the cursor isn't on a
+      # token.
+      def current_token(buffer, cursor)
+        prefix = buffer.chars.first(cursor).join
+        # Only the FIRST token on the line completes (a leading /command, or an
+        # @mention anywhere the run back to a space starts with @).
+        m = prefix.match(%r{(?:\A|\s)([/@]\S*)\z})
+        return nil unless m
+
+        [m[1], m.begin(1)]
+      end
+
+      # When the buffer is an ARGUMENT position of a slash command — i.e.
+      # `/<cmd> [args…] <partial>` with the cursor in the trailing argument —
+      # returns [command, partial, partial_start, args] so
+      # {#completion_context} can complete it; nil otherwise. +args+ are the
+      # COMPLETE arguments before the partial, so a positional source can own a
+      # subcommand grammar (`/agents <id> steer|probe|--stop`, #39); whether a
+      # position completes at all is the CompletionSource's call (a
+      # single-argument command like /skills stops after its first).
+      def command_arg_context(buffer, cursor)
+        prefix = buffer.chars.first(cursor).join
+        m = prefix.match(%r{\A/(\S+)((?:[ \t]+\S+)*)[ \t]+(\S*)\z})
+        return nil unless m
+
+        [m[1], m[3], m.begin(3), m[2].split]
+      end
+
+      def candidates(token)
+        @completion.candidates_for(token)
+      rescue StandardError
+        []
+      end
+
+      # Argument candidates for a slash command (e.g. skill names for `/skills`,
+      # ids + steer/probe/--stop for `/agents`), via the CompletionSource.
+      # Guarded so a registry hiccup degrades the menu to closed rather than
+      # crashing the prompt — same contract as #candidates.
+      def arg_candidates(command, partial, args)
+        return [] unless @completion.respond_to?(:arg_candidates_for)
+
+        @completion.arg_candidates_for(command, partial, args)
+      rescue StandardError
+        []
+      end
+
+      # The visible window's top index so the selected row stays in view.
+      def window_top(selected, size)
+        return 0 if size <= MAX_ROWS
+
+        top = @state ? @state[:top] : 0
+        top = selected if selected < top
+        top = selected - MAX_ROWS + 1 if selected >= top + MAX_ROWS
+        top.clamp(0, size - MAX_ROWS)
+      end
+
+      def pastel
+        @pastel ||= Pastel.new
+      end
+    end
+  end
+end

data/lib/rubino/ui/completion_source.rb

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+require "pastel"
+require "open3"
+
+module Rubino
+  module UI
+    # Shared completion DISCOVERY + token HIGHLIGHT for the interactive prompt.
+    # The bottom composer's /command + @file completion menu and token highlight
+    # consult this single implementation (git→rg→glob walk, @file candidate
+    # shaping, caps/TTL cache, cyan leading-token highlight) instead of each
+    # path duplicating it.
+    #
+    #   * +candidates_for(token)+ — slash commands or @file paths for a token.
+    #   * +highlight_line(line)+  — cyan the leading /command / @mention token.
+    #
+    # Discovery is fastest-first (git tracked+untracked honoring .gitignore →
+    # ripgrep --files → a capped Dir.glob walk) and memoized for a few seconds so
+    # a burst of @ keystrokes never reshells. Every tier is guarded so a failure
+    # degrades to the next tier (and finally to []), never crashing the prompt.
+    class CompletionSource
+      # Tokens that trigger highlighting at the start of the line. A leading
+      # `!` (the bang shell escape) glows like `/` so the user can SEE the
+      # line will run as a shell command, not a message — highlight only, it
+      # never opens the completion menu.
+      TRIGGER_TOKEN = %r{\A([/@]\S+|!\S*)}
+
+      # Cap on candidates — keeps the menu skimmable and bounds work on huge
+      # repos. Cline et al. ship similar caps.
+      MAX_CANDIDATES = 30
+
+      # How long a computed file list stays warm before the next `@` reshells.
+      FILE_CACHE_TTL = 5.0
+
+      # Hardcoded ignore set for the last-resort Dir.glob walk (git/rg already
+      # honor .gitignore; this is only the fallback's safety net).
+      GLOB_IGNORE_DIRS = %w[.git node_modules vendor tmp log .bundle].freeze
+
+      # Hard ceiling on the Dir.glob fallback so a giant tree can't hang the
+      # prompt while we walk it.
+      GLOB_MAX_FILES = 5000
+
+      # The `✗ none` clear entry shown at the TOP of an argument list whose
+      # command supports clearing its active selection (e.g. `/skills`). Picking
+      # it submits the bare sentinel so the command handler clears the slot.
+      NONE_ENTRY = "✗ none"
+
+      # @param commands [Array<String>] the slash-command names (incl. leading /)
+      # @param files [#call, nil] lazy proc returning the workspace root to scan
+      # @param arg_sources [Hash{String=>#call}] maps a BARE command name (no
+      #   leading slash, e.g. "skills") to a proc returning that command's
+      #   argument candidates. Two shapes:
+      #     * a NO-ARG proc — a single-argument command (e.g. "skills" → the
+      #       skill names); only the FIRST argument completes, and the list is
+      #       prefixed with the `✗ none` clear entry (NONE_ENTRY) so the picker
+      #       can clear the active selection from the top.
+      #     * a ONE-ARG proc — receives the PRIOR-argument array and decides
+      #       what completes at this position (e.g. "agents": [] → live ids,
+      #       [id] → steer/probe/--stop), so a subcommand grammar is
+      #       discoverable from the same dropdown (#39). No `✗ none` entry is
+      #       injected — but the source may INCLUDE the NONE_ENTRY string in
+      #       its own list (e.g. "skills", whose first position mixes the
+      #       activate-by-name list with the enable/disable verbs, #188), and
+      #       it keeps the same special matching the no-arg shape gives it.
+      #       Closed enums (`/mode`, `/reasoning`, `/think`, #185) use this
+      #       shape too — `->(args) { args.empty? ? VALUES : [] }` — exactly
+      #       because it carries no `✗ none` entry (there is no "clear" for a
+      #       mode; the no-arg shape's prefix would offer a bogus value).
+      #     * a TWO-ARG proc — receives (prior args, the PARTIAL typed so far)
+      #       and OWNS the matching (no additional prefix filter): a
+      #       filesystem-path source (`/add-dir`, #185) expands `~`, which a
+      #       literal prefix filter would drop. No `✗ none` entry.
+      # @param descriptions [Hash{String=>String}] one-line description per
+      #   candidate string (e.g. BuiltIns::DESCRIPTIONS), rendered dim next to
+      #   the name in the dropdown (#39). Candidates without an entry show
+      #   bare, as before.
+      def initialize(commands: [], files: nil, arg_sources: {}, descriptions: {})
+        @commands        = Array(commands).uniq
+        @files_root_proc = files
+        @arg_sources     = arg_sources || {}
+        @descriptions    = descriptions || {}
+        @pastel          = Pastel.new
+      end
+
+      # Candidates for a completion token. A `/`-prefixed token completes from
+      # the command list; an `@`-prefixed token completes from workspace files;
+      # anything else has no candidates. Case-insensitive prefix matching.
+      def candidates_for(token)
+        case token
+        when %r{\A/}
+          down = token.downcase
+          @commands.select { |c| c.downcase.start_with?(down) }
+        when /\A@/
+          file_candidates(token)
+        else
+          []
+        end
+      end
+
+      # Candidates for the ARGUMENT of a command, e.g. the skill names when the
+      # buffer is `/skills <partial>`. +command+ is the bare command name (no
+      # leading slash); +partial+ is the text typed so far for the argument
+      # (may be empty); +args+ the COMPLETE arguments typed before it. Returns
+      # [] when the command has no registered argument source.
+      #
+      # Candidates are filtered by case-insensitive prefix and capped at
+      # MAX_CANDIDATES — the SAME cap the `/command` and `@file` lists honor.
+      # A no-arg source (single-argument command) completes only the first
+      # argument and leads with the `✗ none` clear entry; a one-arg source is
+      # called with +args+ and owns the per-position grammar (#39) — see
+      # #initialize.
+      def arg_candidates_for(command, partial, args = [])
+        source = @arg_sources[command.to_s]
+        return [] unless source
+
+        down = partial.to_s.downcase
+        list =
+          if source.arity.zero?
+            return [] unless args.empty? # single-argument command: first arg only
+
+            # The `✗ none` clear entry matches an empty partial or a
+            # "n"/"no…"/"none" prefix, so typing toward "none" keeps it in view.
+            none = down.empty? || NONE.start_with?(down) ? [NONE_ENTRY] : []
+            none + Array(source.call).select { |n| n.to_s.downcase.start_with?(down) }
+          elsif source.arity == 2
+            # PARTIAL-AWARE source: it derives candidates FROM the typed text
+            # (e.g. a filesystem glob) and owns the matching — see #initialize.
+            Array(source.call(args, partial.to_s))
+          else
+            positional_candidates(source.call(args), down)
+          end
+        list.first(MAX_CANDIDATES)
+      end
+
+      # Prefix-filtered candidates from a positional (one-arg) source. A
+      # literal NONE_ENTRY in the source's list (the /skills first position,
+      # #188) keeps the clear entry's special matching — shown on an empty
+      # partial or while typing toward "none" — instead of being dropped by
+      # the literal `✗ ` prefix filter.
+      def positional_candidates(list, down)
+        list     = Array(list)
+        has_none = list.delete(NONE_ENTRY)
+        matched  = list.select { |n| n.to_s.downcase.start_with?(down) }
+        return matched unless has_none && (down.empty? || NONE.start_with?(down))
+
+        [NONE_ENTRY] + matched
+      end
+
+      # Directory candidates for a PATH-shaped argument (`/add-dir `, #185) —
+      # the directory-flavored sibling of the `@file` picker. Globs the
+      # filesystem from the typed partial (relative to cwd, absolute, or
+      # `~`-prefixed — an added root usually lives OUTSIDE the workspace, so
+      # the workspace file list is the wrong source here), keeps only
+      # directories, and folds `~` back so the spliced candidate preserves the
+      # user's spelling. Best-effort: any failure (e.g. `~nouser`) returns [].
+      def self.directory_candidates(partial)
+        text    = partial.to_s
+        pattern = text.start_with?("~") ? File.expand_path(text) : text
+        Dir.glob("#{pattern}*")
+           .select { |p| File.directory?(p) }
+           .sort
+           .map { |p| text.start_with?("~") ? p.sub(File.expand_path("~"), "~") : p }
+           .first(MAX_CANDIDATES)
+      rescue StandardError
+        []
+      end
+
+      # The sentinel a `✗ none` selection resolves to once spliced + submitted —
+      # the command handler treats this argument as "clear the active selection".
+      NONE = "none"
+
+      # The one-line description for a dropdown candidate (#39): the same
+      # strings /help shows for a `/command`, a usage hint for a subcommand.
+      # nil when the candidate has none (files, skill names) — the menu row
+      # renders bare, exactly as before.
+      def description_for(candidate)
+        @descriptions[candidate.to_s]
+      end
+
+      # Subtly colorize a leading /command or @mention token (cyan). Plain text
+      # and non-strings are returned unchanged. Matches LineInput#highlight_line.
+      # A "[Pasted text #N +M lines]" paste placeholder (UI::PasteStore) glows
+      # the same way wherever it sits in the line, so the user can SEE it is a
+      # token that expands at send, not literal text.
+      def highlight_line(line)
+        return line unless line.is_a?(String)
+
+        line.sub(TRIGGER_TOKEN) { @pastel.cyan(Regexp.last_match(1)) }
+            .gsub(PasteStore::TOKEN_RE) { |token| @pastel.cyan(token) }
+      end
+
+      private
+
+      # Turn an `@<partial>` token into `@<relpath>` candidates, prefix-matching
+      # the relative path case-insensitively (MVP is prefix-only, as Cline ships).
+      def file_candidates(token)
+        partial = token.sub(/\A@/, "")
+        down    = partial.downcase
+
+        workspace_files
+          .lazy
+          .select { |rel| rel.downcase.start_with?(down) }
+          .map { |rel| "@#{rel}" }
+          .first(MAX_CANDIDATES)
+      end
+
+      # Workspace-relative file list, discovered once per `@` burst and memoized
+      # for FILE_CACHE_TTL so we never reshell on every keystroke.
+      def workspace_files
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        return @files_cache if @files_cache && @files_cache_at && (now - @files_cache_at) < FILE_CACHE_TTL
+
+        @files_cache    = discover_files(workspace_root)
+        @files_cache_at = now
+        @files_cache
+      end
+
+      # Same source of truth as Tools::Base#workspace_root (the primary root).
+      def workspace_root
+        root = @files_root_proc&.call if @files_root_proc
+        root || Rubino::Workspace.primary_root
+      rescue StandardError
+        Dir.pwd
+      end
+
+      # Ignore-aware file discovery, fastest-first. Any failure at a tier falls
+      # through; if everything fails we return [] and the prompt keeps working.
+      def discover_files(root)
+        return [] unless root && File.directory?(root)
+
+        git_files(root) || rg_files(root) || glob_files(root) || []
+      rescue StandardError
+        []
+      end
+
+      # (1) git: tracked + untracked, honoring .gitignore. nil (not []) on
+      # failure so the caller falls through to the next tier. err: File::NULL so
+      # git's "fatal: not a git repository" never bleeds onto the prompt (D5).
+      def git_files(root)
+        out, status = Open3.capture2(
+          "git", "ls-files", "--cached", "--others", "--exclude-standard",
+          chdir: root, err: File::NULL
+        )
+        return nil unless status.success?
+
+        out.split("\n").reject(&:empty?)
+      rescue StandardError
+        nil
+      end
+
+      # (2) ripgrep: --files lists every file rg would search (.gitignore aware).
+      def rg_files(root)
+        return nil unless ripgrep_available?
+
+        out, status = Open3.capture2("rg", "--files", chdir: root, err: File::NULL)
+        return nil unless status.success?
+
+        out.split("\n").reject(&:empty?)
+      rescue StandardError
+        nil
+      end
+
+      def ripgrep_available?
+        system("which rg > /dev/null 2>&1")
+      end
+
+      # (3) last resort: a capped, ignore-aware Dir.glob walk.
+      def glob_files(root)
+        files = []
+        Dir.glob("**/*", File::FNM_DOTMATCH, base: root) do |rel|
+          next if [".", ".."].include?(rel)
+          next if GLOB_IGNORE_DIRS.any? { |d| rel == d || rel.start_with?("#{d}/") }
+          next unless File.file?(File.join(root, rel))
+
+          files << rel
+          break if files.size >= GLOB_MAX_FILES
+        end
+        files
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end