rubyn-code 0.4.0 → 0.5.1

data/lib/rubyn_code/skills/pack_manager.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+
+module RubynCode
+  module Skills
+    # Manages local installation, removal, and updates of skill packs
+    # with ETag caching and offline fallback support.
+    #
+    # Installed packs live under ~/.rubyn-code/skill-packs/<pack-name>/.
+    # A manifest.json in each pack directory records metadata for listing,
+    # version tracking, and ETag-based conditional updates.
+    class PackManager
+      PACKS_DIR       = File.join(Config::Defaults::HOME_DIR, 'skill-packs')
+      MANIFEST_FILE   = 'manifest.json'
+      ETAG_CACHE_FILE = '.etags.json'
+      SAFE_NAME_RE    = /\A[a-zA-Z0-9_-]+\z/
+
+      def initialize(packs_dir: PACKS_DIR)
+        @packs_dir = packs_dir
+      end
+
+      # Install a pack from registry response data.
+      #
+      # @param pack_data [Hash] from RegistryClient#fetch_pack[:data]
+      #   Expected keys: :name, :description, :version, :files
+      #   Each file: { filename: "name.md", content: "..." }
+      # @param etag [String, nil] ETag from registry response for cache tracking
+      # @return [Hash] installed pack metadata
+      def install(pack_data, etag: nil)
+        name = fetch_key(pack_data, :name)
+        raise ArgumentError, 'Pack data must include a name' if name.nil? || name.empty?
+
+        validate_name!(name)
+        pack_dir = pack_path(name)
+        FileUtils.mkdir_p(pack_dir)
+
+        write_files(pack_dir, pack_data)
+        write_manifest(pack_dir, pack_data, etag: etag)
+        store_etag(name, etag) if etag
+
+        manifest(name)
+      end
+
+      # Update a single installed pack using ETag-based conditional fetch.
+      # Returns :updated, :up_to_date, or :not_installed.
+      #
+      # @param name [String] pack name
+      # @param registry [RegistryClient] registry client to fetch from
+      # @return [Symbol] update result
+      def update(name, registry)
+        validate_name!(name)
+        return :not_installed unless installed?(name)
+
+        cached_etag = load_etag(name)
+        result = registry.fetch_pack(name, etag: cached_etag)
+
+        return :up_to_date if result[:not_modified]
+
+        install(result[:data], etag: result[:etag])
+        :updated
+      end
+
+      # Update all installed packs. Returns a hash of { name => status }.
+      #
+      # @param registry [RegistryClient]
+      # @return [Hash<String, Symbol>]
+      def update_all(registry)
+        installed.each_with_object({}) do |pack, results|
+          name = pack[:name]
+          results[name] = update(name, registry)
+        rescue RegistryError => e
+          results[name] = :"error: #{e.message}"
+        end
+      end
+
+      # Remove an installed pack with path traversal protection.
+      #
+      # @param name [String] pack name
+      # @return [Boolean] true if removed, false if not found
+      def remove(name)
+        validate_name!(name)
+        pack_dir = pack_path(name)
+        return false unless File.directory?(pack_dir)
+
+        # Verify the resolved path is within packs_dir to prevent traversal
+        real_pack = File.realpath(pack_dir)
+        real_base = File.realpath(@packs_dir)
+        unless real_pack.start_with?("#{real_base}/")
+          raise ArgumentError, "Pack directory is outside the skill-packs directory"
+        end
+
+        FileUtils.rm_rf(pack_dir)
+        remove_etag(name)
+        true
+      end
+
+      # List all installed packs.
+      #
+      # @return [Array<Hash>] each with :name, :description, :version, :installed_at
+      def installed
+        return [] unless File.directory?(@packs_dir)
+
+        Dir.children(@packs_dir)
+           .select { |d| File.directory?(File.join(@packs_dir, d)) }
+           .reject { |d| d.start_with?('.') }
+           .filter_map { |d| manifest(d) }
+           .sort_by { |m| m[:name] }
+      end
+
+      # Check if a pack is installed.
+      #
+      # @param name [String]
+      # @return [Boolean]
+      def installed?(name)
+        manifest_path = File.join(@packs_dir, name.to_s, MANIFEST_FILE)
+        File.exist?(manifest_path)
+      end
+
+      # Return the skills directory for a pack (for catalog integration).
+      #
+      # @param name [String]
+      # @return [String, nil] path to pack directory or nil
+      def pack_skills_dir(name)
+        dir = pack_path(name)
+        File.directory?(dir) ? dir : nil
+      end
+
+      # Return all installed pack directories (for skill loader integration).
+      #
+      # @return [Array<String>]
+      def all_pack_dirs
+        installed.map { |pack| pack_path(pack[:name]) }.select { |d| File.directory?(d) }
+      end
+
+      private
+
+      def pack_path(name)
+        File.join(@packs_dir, name.to_s)
+      end
+
+      # Validate pack name contains only safe characters.
+      def validate_name!(name)
+        return if name.to_s.match?(SAFE_NAME_RE)
+
+        raise ArgumentError,
+              "Invalid pack name: '#{name}'. Only letters, numbers, hyphens, and underscores allowed."
+      end
+
+      def fetch_key(hash, key)
+        hash[key] || hash[key.to_s]
+      end
+
+      def manifest(name)
+        path = File.join(@packs_dir, name.to_s, MANIFEST_FILE)
+        return nil unless File.exist?(path)
+
+        JSON.parse(File.read(path), symbolize_names: true)
+      rescue JSON::ParserError
+        nil
+      end
+
+      def write_files(pack_dir, pack_data)
+        files = fetch_key(pack_data, :files) || []
+        files.each { |file| write_single_file(pack_dir, file) }
+      end
+
+      def write_single_file(pack_dir, file)
+        filename = fetch_key(file, :filename)
+        content  = fetch_key(file, :content)
+        return if filename.nil? || content.nil?
+
+        # Prevent path traversal in filenames
+        safe_name = File.basename(filename)
+        File.write(File.join(pack_dir, safe_name), content)
+      end
+
+      def write_manifest(pack_dir, pack_data, etag: nil)
+        manifest_data = {
+          name: fetch_key(pack_data, :name),
+          description: fetch_key(pack_data, :description) || '',
+          version: fetch_key(pack_data, :version) || '1.0.0',
+          skillCount: (fetch_key(pack_data, :files) || []).size,
+          etag: etag,
+          installed_at: Time.now.iso8601,
+          updated_at: Time.now.iso8601
+        }
+
+        File.write(
+          File.join(pack_dir, MANIFEST_FILE),
+          JSON.pretty_generate(manifest_data)
+        )
+      end
+
+      # ── ETag Cache ────────────────────────────────────────────────
+
+      def etag_cache_path
+        File.join(@packs_dir, ETAG_CACHE_FILE)
+      end
+
+      def load_etag_cache
+        return {} unless File.exist?(etag_cache_path)
+
+        JSON.parse(File.read(etag_cache_path))
+      rescue JSON::ParserError
+        {}
+      end
+
+      def load_etag(name)
+        load_etag_cache[name.to_s]
+      end
+
+      def store_etag(name, etag)
+        FileUtils.mkdir_p(@packs_dir)
+        cache = load_etag_cache
+        cache[name.to_s] = etag
+        File.write(etag_cache_path, JSON.pretty_generate(cache))
+      end
+
+      def remove_etag(name)
+        return unless File.exist?(etag_cache_path)
+
+        cache = load_etag_cache
+        cache.delete(name.to_s)
+        File.write(etag_cache_path, JSON.pretty_generate(cache))
+      end
+    end
+  end
+end

data/lib/rubyn_code/skills/registry_autoload.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Skills
+    # Web fallback for trigger-based skill autoload.
+    #
+    # When the user message matches a skill pack in the registry that the
+    # user hasn't installed locally, fetch the pack, install it under
+    # ~/.rubyn-code/skill-packs/, refresh the loader's catalog, and let the
+    # local matcher pick up the freshly-available skills.
+    #
+    # Pack-level matching (decided up front): substring-match the user
+    # message against each pack's :name and :tags. Skill-level triggers
+    # aren't in the registry catalog yet, so we pull packs at the coarser
+    # grain and let the local matcher take over once files land on disk.
+    #
+    # Failure modes are silent: a registry error returns no matches so the
+    # turn proceeds as if the web fallback weren't there.
+    class RegistryAutoload
+      # @param loader [Skills::Loader] supplies the live catalog to refresh after install
+      # @param matcher [Skills::Matcher] re-run after install to extract real skill matches
+      # @param registry_client [Skills::RegistryClient, nil] defaults to a new client
+      # @param pack_manager [Skills::PackManager, nil] defaults to a new manager
+      # @param on_fetching [Proc, nil] called as on_fetching.call(pack_name) before each fetch
+      def initialize(loader:, matcher:, registry_client: nil, pack_manager: nil, on_fetching: nil)
+        @loader = loader
+        @matcher = matcher
+        @client = registry_client || RegistryClient.new
+        @pack_manager = pack_manager || PackManager.new
+        @on_fetching = on_fetching || ->(_name) {}
+        @attempted = Set.new
+        @catalog_cache = nil
+        @catalog_fetch_failed = false
+      end
+
+      # Attempt to install and match uninstalled packs whose name or tags
+      # appear in the user message.
+      #
+      # @param user_input [String]
+      # @return [Array<Hash>] catalog entries (from the local matcher) that
+      #   became matchable after install. Empty if nothing fetched or the
+      #   registry is unreachable.
+      def try(user_input)
+        text = user_input.to_s.downcase
+        return [] if text.empty?
+
+        candidates = uninstalled_packs_matching(text)
+        return [] if candidates.empty?
+
+        installed_any = candidates.any? { |pack| attempt_install(pack) }
+        return [] unless installed_any
+
+        @loader.catalog.refresh!
+        @matcher.match(user_input)
+      end
+
+      private
+
+      def uninstalled_packs_matching(text)
+        packs = registry_catalog
+        return [] if packs.nil?
+
+        packs.select do |pack|
+          name = pack_name(pack)
+          next false if name.nil? || name.empty?
+          next false if @pack_manager.installed?(name)
+          next false if @attempted.include?(name)
+
+          pack_matches?(pack, name, text)
+        end
+      end
+
+      def pack_matches?(pack, name, text)
+        return true if text.include?(name.downcase)
+
+        Array(pack[:tags] || pack['tags']).any? do |tag|
+          text.include?(tag.to_s.downcase)
+        end
+      end
+
+      def attempt_install(pack)
+        name = pack_name(pack)
+        @attempted << name
+
+        @on_fetching.call(name)
+        result = @client.fetch_pack(name)
+        @pack_manager.install(result[:data], etag: result[:etag])
+        true
+      rescue StandardError => e
+        RubynCode::Debug.warn("Web autoload failed for '#{name}': #{e.message}")
+        false
+      end
+
+      # Cache the registry catalog for the session. One failure flips
+      # @catalog_fetch_failed so we don't hammer the registry on every turn.
+      def registry_catalog
+        return nil if @catalog_fetch_failed
+        return @catalog_cache if @catalog_cache
+
+        @catalog_cache = @client.fetch_catalog[:data] || []
+      rescue StandardError => e
+        RubynCode::Debug.warn("Web autoload registry fetch failed: #{e.message}")
+        @catalog_fetch_failed = true
+        nil
+      end
+
+      def pack_name(pack)
+        (pack[:name] || pack['name']).to_s
+      end
+    end
+  end
+end

data/lib/rubyn_code/skills/registry_client.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'faraday'
+require 'json'
+
+module RubynCode
+  module Skills
+    # HTTP client for the rubyn.ai skill packs registry API.
+    # Supports ETag-based conditional requests for efficient cache
+    # validation and offline resilience.
+    class RegistryClient
+      LEADING_SLASHES_REGEX = %r{\A/+}
+      DEFAULT_BASE_URL = 'https://rubyn.ai'
+      TIMEOUT_SECONDS  = 10
+      USER_ACCEPT_HEADER = 'Rubyn Code'
+
+      attr_reader :base_url
+
+      def initialize(base_url: nil)
+        @base_url = base_url || ENV.fetch('RUBYN_REGISTRY_URL', DEFAULT_BASE_URL)
+      end
+
+      # List all available packs (returns flat array for CLI commands).
+      #
+      # @param etag [String, nil] cached ETag for conditional request
+      # @return [Array<Hash>] array of pack metadata
+      # @raise [RegistryError] on network or parse failure
+      def list_packs(etag: nil)
+        fetch_catalog(etag: etag)[:data] || []
+      end
+
+      # Fetch the full catalog of available skill packs.
+      #
+      # @param etag [String, nil] cached ETag for conditional request
+      # @return [Hash] { data: Array<Hash>, etag: String|nil, not_modified: Boolean }
+      # @raise [RegistryError] on network or parse failure
+      def fetch_catalog(etag: nil)
+        response = conditional_get('/api/v1/skills/packs.json', etag: etag)
+        return not_modified_result if response.status == 304
+
+        data = validate_and_parse(response)
+        packs = normalize_packs(data)
+        { data: packs, etag: response.headers['etag'], not_modified: false }
+      rescue Faraday::Error => e
+        raise RegistryError, "Failed to fetch skill catalog: #{e.message}"
+      end
+
+      # Search packs by keyword.
+      # Note: The registry API does not support server-side search.
+      # This method fetches the catalog and filters locally.
+      #
+      # @param query [String]
+      # @param etag [String, nil] cached ETag for conditional request
+      # @return [Hash] { data: Array<Hash>, etag: String|nil, not_modified: Boolean }
+      # @raise [RegistryError] on network or parse failure
+      def search_packs(query, etag: nil)
+        catalog = fetch_catalog(etag: etag)
+        return catalog if catalog[:not_modified]
+
+        q = query.to_s.downcase
+        filtered = catalog[:data].select { |pack| matches_query?(pack, q) }
+        { data: filtered, etag: catalog[:etag], not_modified: false }
+      end
+
+      # Fetch pack suggestions based on detected gems.
+      #
+      # @param gems [Array<String>] list of gem names detected in the project
+      # @return [Array<Hash>] array of { name: String, reason: String }
+      # @raise [RegistryError] on network or parse failure
+      def fetch_suggestions(gems)
+        return [] if gems.empty?
+
+        gems_param = gems.join(',')
+        response = connection.get('/api/v1/skills/packs/suggest', { gems: gems_param })
+        return [] if response.status == 404
+
+        data = validate_and_parse(response)
+        suggestions = data[:suggestions] || data['suggestions'] || []
+        suggestions.is_a?(Array) ? suggestions : []
+      rescue Faraday::Error => e
+        raise RegistryError, "Failed to fetch suggestions: #{e.message}"
+      end
+
+      # Fetch a single pack's full content for installation.
+      # Fetches pack metadata and all skill file contents.
+      #
+      # @param name [String] pack name (validated for safe characters)
+      # @param etag [String, nil] cached ETag for conditional request
+      # @return [Hash] { data: Hash, etag: String|nil, not_modified: Boolean }
+      # @raise [RegistryError] on not found, validation, or network failure
+      def fetch_pack(name, etag: nil)
+        validate_pack_name!(name)
+        response = conditional_get("/api/v1/skills/packs/#{encode_name(name)}.json", etag: etag)
+        return not_modified_result if response.status == 304
+
+        data = validate_and_parse(response)
+        validate_pack_response!(data, name)
+
+        # Fetch individual file contents. Manifests may list files under
+        # :files (as { path: ... } hashes) or :skills (as filename strings).
+        files = fetch_key(data, :files) || fetch_key(data, :skills) || []
+        files = files.map { |f| f.is_a?(String) ? { path: f } : f }
+        data[:files] = fetch_files_with_content(name, files)
+
+        { data: data, etag: response.headers['etag'], not_modified: false }
+      rescue Faraday::Error => e
+        raise RegistryError, "Failed to fetch pack '#{name}': #{e.message}"
+      end
+
+      # Fetch a single skill file's markdown content.
+      #
+      # @param pack_name [String]
+      # @param file_path [String]
+      # @param etag [String, nil] cached ETag for conditional request
+      # @return [Hash] { content: String, etag: String|nil, not_modified: Boolean }
+      # @raise [RegistryError] on not found or network failure
+      def fetch_file(pack_name, file_path, etag: nil)
+        validate_pack_name!(pack_name)
+        safe_path = file_path.to_s.gsub('..', '').gsub(LEADING_SLASHES_REGEX, '')
+        response = connection.get(
+          "/api/v1/skills/packs/#{encode_name(pack_name)}/files/#{ERB::Util.url_encode(safe_path)}"
+        ) do |req|
+          req.headers['If-None-Match'] = etag if etag
+        end
+
+        return { content: nil, etag: nil, not_modified: true } if response.status == 304
+        return { content: response.body, etag: response.headers['etag'], not_modified: false } if response.success?
+
+        raise RegistryError, "Failed to fetch file '#{file_path}' from pack '#{pack_name}'"
+      rescue Faraday::Error => e
+        raise RegistryError, "Failed to fetch file '#{file_path}': #{e.message}"
+      end
+
+      private
+
+      def connection
+        @connection ||= Faraday.new(url: base_url) do |f|
+          f.request :url_encoded
+          f.response :raise_error
+          f.options.timeout = TIMEOUT_SECONDS
+          f.options.open_timeout = TIMEOUT_SECONDS
+          f.headers['Accept'] = 'application/json'
+          f.headers['User-Accept'] = USER_ACCEPT_HEADER
+          f.headers['User-Agent'] = "rubyn-code/#{RubynCode::VERSION}"
+        end
+      end
+
+      # Perform a GET with optional ETag-based conditional caching.
+      # Sends If-None-Match when an ETag is provided; server returns
+      # 304 Not Modified if content hasn't changed.
+      def conditional_get(path, etag: nil, params: {})
+        connection.get(path) do |req|
+          req.params.merge!(params) unless params.empty?
+          req.headers['If-None-Match'] = etag if etag
+        end
+      end
+
+      def validate_and_parse(response)
+        body = response.body.to_s.strip
+        raise RegistryError, 'Empty response from registry' if body.empty?
+
+        content_type = response.headers['content-type'].to_s
+        if !content_type.include?('json') && body.start_with?('<')
+          raise RegistryError,
+                'Registry endpoint returned HTML instead of JSON ' \
+                "(content-type: #{content_type}). The skill packs API may not be available at #{base_url}."
+        end
+
+        JSON.parse(body, symbolize_names: true)
+      rescue JSON::ParserError => e
+        raise RegistryError, "Invalid response from registry: #{e.message}"
+      end
+
+      # Normalize response into an array of pack hashes.
+      # Handles both bare arrays and { packs: [...] } wrapper shapes.
+      def normalize_packs(data)
+        return data if data.is_a?(Array)
+        return data[:packs] if data.is_a?(Hash) && data[:packs].is_a?(Array)
+
+        raise RegistryError, 'Unexpected catalog format from registry'
+      end
+
+      def validate_pack_response!(data, name)
+        return if data.is_a?(Hash) && (data[:name] || data[:files])
+
+        raise RegistryError, "Invalid pack response for '#{name}': missing name or files"
+      end
+
+      # Only allow alphanumeric, hyphens, underscores, and forward slashes in pack names.
+      # Forward slashes are required for namespaced packs like 'stripe/webhooks'.
+      def validate_pack_name!(name)
+        return if name.to_s.match?(%r{\A[a-zA-Z0-9_\-/]+\z})
+
+        raise RegistryError,
+              "Invalid pack name: '#{name}'. Only letters, numbers, hyphens, underscores, and slashes allowed."
+      end
+
+      def encode_name(name)
+        ERB::Util.url_encode(name.to_s)
+      end
+
+      def fetch_key(hash, key)
+        hash[key] || hash[key.to_s]
+      end
+
+      def matches_query?(pack, query)
+        pack_name = pack[:name].to_s.downcase
+        pack_display = pack[:displayName].to_s.downcase
+        pack_desc = pack[:description].to_s.downcase
+        pack_tags = pack[:tags] || []
+
+        pack_name.include?(query) ||
+          pack_display.include?(query) ||
+          pack_desc.include?(query) ||
+          pack_tags.any? { |t| t.to_s.downcase.include?(query) }
+      end
+
+      # Fetch markdown content for each file in the pack and transform
+      # into the format expected by PackManager: { filename, content }
+      def fetch_files_with_content(pack_name, files)
+        return files if files.empty?
+
+        files.map do |file|
+          path = fetch_key(file, :path)
+          result = fetch_file(pack_name, path)
+          { filename: path, content: result[:content] }
+        rescue RegistryError
+          # Skip files that fail to load
+          nil
+        end.compact
+      end
+
+      def not_modified_result
+        { data: nil, etag: nil, not_modified: true }
+      end
+    end
+
+    class RegistryError < RubynCode::Error; end
+  end
+end

data/lib/rubyn_code/tools/executor.rb

@@ -16,7 +16,8 @@ module RubynCode
         Registry.load_all!
       end
 
-      def execute(tool_name, params) # rubocop:disable Metrics/AbcSize -- maps tool errors to results
+      # -- maps tool errors to results
+      def execute(tool_name, params)
         # File cache intercept: serve cached reads, invalidate on writes
         cached = try_file_cache(tool_name, params)
         return cached if cached
@@ -73,7 +74,8 @@ module RubynCode
         allowed.empty? ? symbolized : symbolized.slice(*allowed)
       end
 
-      def inject_dependencies(tool, tool_name) # rubocop:disable Metrics/CyclomaticComplexity -- tool-specific dependency injection
+      # -- tool-specific dependency injection
+      def inject_dependencies(tool, tool_name)
         case tool_name
         when 'spawn_agent', 'spawn_teammate'
           inject_agent_deps(tool)

data/lib/rubyn_code/tools/grep.rb

@@ -23,7 +23,8 @@ module RubynCode
       def self.summarize(output, args)
         pattern = args['pattern'] || args[:pattern] || ''
         count = output.to_s.lines.count
-        count.zero? || output.to_s.start_with?('No matches') ? "grep #{pattern} (0 matches)" : "grep #{pattern} (#{count} lines)"
+        no_matches = count.zero? || output.to_s.start_with?('No matches')
+        no_matches ? "grep #{pattern} (0 matches)" : "grep #{pattern} (#{count} lines)"
       end
 
       def execute(pattern:, path: nil, glob_filter: nil, max_results: 50)

data/lib/rubyn_code/tools/ide_diagnostics.rb

@@ -6,7 +6,9 @@ module RubynCode
     # via the IDE RPC bridge. Only available when running in IDE mode.
     class IdeDiagnostics < Base
       TOOL_NAME = 'ide_diagnostics'
-      DESCRIPTION = 'Get VS Code diagnostics (errors, warnings) for a file or the whole workspace. Only available in IDE mode.'
+      DESCRIPTION =
+        'Get VS Code diagnostics (errors, warnings) for a file or the whole workspace. ' \
+        'Only available in IDE mode.'
       PARAMETERS = {
         file: {
           type: 'string',

data/lib/rubyn_code/tools/ide_symbols.rb

@@ -6,7 +6,9 @@ module RubynCode
     # Only available when running in IDE mode.
     class IdeSymbols < Base
       TOOL_NAME = 'ide_symbols'
-      DESCRIPTION = 'Search workspace symbols (classes, methods, modules) via VS Code language server. Only available in IDE mode.'
+      DESCRIPTION =
+        'Search workspace symbols (classes, methods, modules) via VS Code language server. ' \
+        'Only available in IDE mode.'
       PARAMETERS = {
         query: {
           type: 'string',

data/lib/rubyn_code/tools/load_skill.rb

@@ -36,7 +36,8 @@ module RubynCode
         skills_dirs = [
           File.expand_path('../../../skills', __dir__), # bundled gem skills
           File.join(project_root, '.rubyn-code', 'skills'), # project skills
-          File.join(Dir.home, '.rubyn-code', 'skills') # global user skills
+          File.join(Dir.home, '.rubyn-code', 'skills'), # global user skills
+          File.join(Dir.home, '.rubyn-code', 'skill-packs') # registry-installed packs
         ]
         catalog = Skills::Catalog.new(skills_dirs.select { |d| Dir.exist?(d) })
         Skills::Loader.new(catalog)

data/lib/rubyn_code/tools/output_compressor.rb

@@ -103,7 +103,7 @@ module RubynCode
         failures
       end
 
-      # rubocop:disable Metrics/AbcSize -- head/tail splitting requires coordinated arithmetic
+      # -- head/tail splitting requires coordinated arithmetic
       def head_tail(output, max_chars)
         lines = output.lines
         return output if lines.size <= 10
@@ -120,9 +120,8 @@ module RubynCode
         parts << tail_lines.join
         parts.join
       end
-      # rubocop:enable Metrics/AbcSize
 
-      # rubocop:disable Metrics/AbcSize -- diff hunk iteration with header extraction
+      # -- diff hunk iteration with header extraction
       def compress_diff(output, max_chars)
         hunks = output.split(/^(?=diff --git)/)
         return head_tail(output, max_chars) if hunks.size <= 1
@@ -140,7 +139,6 @@ module RubynCode
 
         result
       end
-      # rubocop:enable Metrics/AbcSize
 
       def top_matches(output, max_chars)
         lines = output.lines
@@ -152,7 +150,7 @@ module RubynCode
         result
       end
 
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity -- multi-step tree collapse
+      # -- multi-step tree collapse
       def collapse_tree(output, max_chars)
         paths = output.lines.map(&:strip).reject(&:empty?)
         return output if output.length <= max_chars
@@ -164,7 +162,6 @@ module RubynCode
 
         head_tail(result, max_chars)
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
 
       def take_lines_up_to(lines, max_chars)
         taken = []