rubyn-code 0.4.0 → 0.5.0

data/lib/rubyn_code/output/diff_renderer.rb

@@ -97,7 +97,8 @@ module RubynCode
         table
       end
 
-      def fill_lcs_row(table, row, old_lines, new_lines, col_count) # rubocop:disable Metrics/AbcSize -- LCS algorithm step
+      # -- LCS algorithm step
+      def fill_lcs_row(table, row, old_lines, new_lines, col_count)
         (1..col_count).each do |col|
           table[row][col] = if old_lines[row - 1] == new_lines[col - 1]
                               table[row - 1][col - 1] + 1
@@ -121,7 +122,7 @@ module RubynCode
         result
       end
 
-      def backtrack_step(result, table, old_lines, new_lines, old_idx, new_idx) # rubocop:disable Metrics/AbcSize, Metrics/ParameterLists -- LCS backtrack step requires all state
+      def backtrack_step(result, table, old_lines, new_lines, old_idx, new_idx) # rubocop:disable Metrics/ParameterLists -- LCS backtrack step requires all state
         if lines_match?(old_lines, new_lines, old_idx, new_idx)
           result.unshift([:equal, old_idx - 1, new_idx - 1])
           [old_idx - 1, new_idx - 1]

data/lib/rubyn_code/self_test.rb

@@ -53,7 +53,8 @@ module RubynCode
       record('File read (version.rb)', content.include?('VERSION ='))
     end
 
-    def check_file_write_edit_cleanup # rubocop:disable Metrics/AbcSize -- sequential file ops
+    # -- sequential file ops
+    def check_file_write_edit_cleanup
       tmp = File.join(project_root, '.rubyn-code/self_test_tmp.rb')
       FileUtils.mkdir_p(File.dirname(tmp))
 

data/lib/rubyn_code/skills/auto_suggest.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'gemfile_parser'
+
+module RubynCode
+  module Skills
+    # Suggests skill packs based on gems detected in the project's Gemfile.
+    #
+    # On session start, parses the Gemfile, queries the registry for matching
+    # packs, and shows a one-time suggestion. Tracks shown suggestions in
+    # `.rubyn-code/suggested.json` to avoid repeating.
+    class AutoSuggest
+      SUGGESTED_FILE = 'suggested.json'
+
+      # @param project_root [String]
+      # @param registry_client [RegistryClient]
+      def initialize(project_root:, registry_client: nil)
+        @project_root = project_root
+        @client = registry_client || RegistryClient.new
+      end
+
+      # Check for suggestable packs and return a display message if any.
+      # Returns nil if no suggestions or if all have been shown/dismissed.
+      #
+      # This method never raises — registry failures are silently swallowed
+      # to avoid blocking session start.
+      #
+      # @return [String, nil] suggestion message or nil
+      def check
+        gems = parse_gemfile
+        return nil if gems.empty?
+
+        suggestions = fetch_suggestions(gems)
+        return nil if suggestions.empty?
+
+        new_suggestions = filter_shown(suggestions)
+        return nil if new_suggestions.empty?
+
+        record_shown(new_suggestions)
+        format_message(new_suggestions)
+      rescue StandardError
+        nil
+      end
+
+      # Mark a pack as installed so it won't be suggested again.
+      #
+      # @param name [String] pack name
+      def mark_installed(name)
+        state = load_state
+        state['installed'] ||= []
+        state['installed'] << name unless state['installed'].include?(name)
+        save_state(state)
+      end
+
+      # Mark a suggestion as dismissed.
+      #
+      # @param name [String] pack name
+      def mark_dismissed(name)
+        state = load_state
+        state['dismissed'] ||= []
+        state['dismissed'] << name unless state['dismissed'].include?(name)
+        save_state(state)
+      end
+
+      private
+
+      def parse_gemfile
+        gemfile_path = File.join(@project_root, 'Gemfile')
+        return [] unless File.exist?(gemfile_path)
+
+        GemfileParser.gems(File.read(gemfile_path))
+      rescue StandardError
+        []
+      end
+
+      def fetch_suggestions(gems)
+        @client.fetch_suggestions(gems)
+      rescue RegistryError
+        []
+      end
+
+      def filter_shown(suggestions)
+        state = load_state
+        shown = Array(state['shown'])
+        installed = Array(state['installed'])
+        dismissed = Array(state['dismissed'])
+        skip = (shown + installed + dismissed).uniq
+
+        suggestions.reject { |s| skip.include?(s['name']) }
+      end
+
+      def record_shown(suggestions)
+        state = load_state
+        state['shown'] ||= []
+        suggestions.each do |s|
+          state['shown'] << s['name'] unless state['shown'].include?(s['name'])
+        end
+        save_state(state)
+      end
+
+      def format_message(suggestions)
+        gem_names = suggestions.map { |s| s['name'] }.join(', ')
+        details = suggestions.map { |s| "#{s['name']} (#{s['reason']})" }.join(', ')
+        install_cmd = "/install-skills #{suggestions.map { |s| s['name'] }.join(' ')}"
+
+        "Skill packs available: #{details}\n" \
+          "Run #{install_cmd} to install."
+      end
+
+      def load_state
+        path = state_path
+        return {} unless File.exist?(path)
+
+        JSON.parse(File.read(path))
+      rescue JSON::ParserError
+        {}
+      end
+
+      def save_state(state)
+        dir = File.dirname(state_path)
+        FileUtils.mkdir_p(dir)
+        File.write(state_path, JSON.pretty_generate(state))
+      end
+
+      def state_path
+        File.join(@project_root, '.rubyn-code', SUGGESTED_FILE)
+      end
+    end
+  end
+end

data/lib/rubyn_code/skills/catalog.rb

@@ -24,6 +24,13 @@ module RubynCode
         @index
       end
 
+      # Force the index to be rebuilt on next access. Used after installing
+      # a skill pack so newly-written files become discoverable in the same
+      # session.
+      def refresh!
+        @index = nil
+      end
+
       def list
         available.map { |e| e[:name] }
       end
@@ -103,6 +110,9 @@ module RubynCode
           name: name,
           description: doc.description,
           tags: doc.tags,
+          triggers: doc.triggers,
+          gems: doc.gems,
+          rails: doc.rails,
           path: File.expand_path(path)
         }
       rescue StandardError

data/lib/rubyn_code/skills/document.rb

@@ -7,12 +7,15 @@ module RubynCode
     class Document
       FRONTMATTER_PATTERN = /\A---\s*\n(.+?\n)---\s*\n(.*)\z/m
 
-      attr_reader :name, :description, :tags, :body
+      attr_reader :name, :description, :tags, :triggers, :gems, :rails, :body
 
-      def initialize(name:, description:, tags:, body:)
+      def initialize(name:, description:, tags:, body:, triggers: [], gems: [], rails: nil) # rubocop:disable Metrics/ParameterLists -- frontmatter-driven, keyword-only is clearer than a metadata hash
         @name = name
         @description = description
         @tags = tags
+        @triggers = triggers
+        @gems = gems
+        @rails = rails
         @body = body
       end
 
@@ -28,6 +31,9 @@ module RubynCode
             name: frontmatter['name'].to_s,
             description: frontmatter['description'].to_s,
             tags: Array(frontmatter['tags']),
+            triggers: Array(frontmatter['triggers']).map(&:to_s),
+            gems: Array(frontmatter['gems']).map(&:to_s),
+            rails: frontmatter['rails']&.to_s,
             body: match[2].to_s.strip
           )
         end

data/lib/rubyn_code/skills/gemfile_parser.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Skills
+    # Parses Gemfiles to extract gem names for skill pack matching.
+    # Handles standard gem declarations and grouped gems.
+    #
+    # Recognized patterns:
+    #   gem 'stripe'
+    #   gem 'stripe', '~> 8.0'
+    #   gem 'pundit', require: false
+    #   gem 'sidekiq', '>= 6.0', group: :workers
+    #
+    # Does NOT match comments or source declarations.
+    class GemfileParser
+      GEM_PATTERN = /
+        ^\s*gem\s+
+        ['"]([^'"]+)['"]
+      /x
+
+      # Extract unique gem names from Gemfile content.
+      #
+      # @param content [String] raw Gemfile content
+      # @return [Array<String>] gem names (lowercase)
+      def self.gems(content)
+        new(content).gems
+      end
+
+      def initialize(content)
+        @content = content
+      end
+
+      def gems
+        return [] if @content.to_s.strip.empty?
+
+        @content.scan(GEM_PATTERN).flatten.map { |m| m.strip.downcase }.uniq
+      end
+    end
+  end
+end

data/lib/rubyn_code/skills/loader.rb

@@ -42,7 +42,7 @@ module RubynCode
       # @param codebase_index [RubynCode::Index::CodebaseIndex, nil]
       # @param project_profile [Object, nil] reserved for future profile-based hints
       # @return [Array<String>] suggested skill names (not loaded automatically)
-      def suggest_skills(codebase_index: nil, project_profile: nil) # rubocop:disable Lint/UnusedMethodArgument, Metrics/CyclomaticComplexity -- project_profile reserved for future use
+      def suggest_skills(codebase_index: nil, project_profile: nil) # rubocop:disable Lint/UnusedMethodArgument
         return [] unless codebase_index
 
         suggestions = []

data/lib/rubyn_code/skills/matcher.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative 'gemfile_parser'
+
+module RubynCode
+  module Skills
+    # Selects which skills to auto-load for a given user message.
+    #
+    # A skill is selected when:
+    #   - its `triggers:` frontmatter list has at least one case-insensitive
+    #     substring hit against the user message, AND
+    #   - every gem in its `gems:` list is present in the project's Gemfile
+    #     (skills with no `gems:` are unrestricted; if there is no Gemfile,
+    #     gem gating is skipped entirely), AND
+    #   - it has not already been selected by this matcher in the current
+    #     session (per-instance dedup).
+    #
+    # Match scope is the latest user turn only. There is no cap on the
+    # number of matches per turn.
+    class Matcher
+      def initialize(catalog:, project_root: nil)
+        @catalog = catalog
+        @project_root = project_root
+        @loaded = Set.new
+      end
+
+      # Find skills whose triggers match `user_message`.
+      #
+      # @param user_message [String]
+      # @return [Array<Hash>] catalog entries to load
+      def match(user_message)
+        text = user_message.to_s.downcase
+        return [] if text.empty?
+
+        available_gems_set = available_gems
+        @catalog.available.filter_map do |entry|
+          next unless eligible?(entry, text, available_gems_set)
+
+          @loaded << entry[:name]
+          entry
+        end
+      end
+
+      # Names of skills selected so far in this session.
+      def loaded
+        @loaded.to_a
+      end
+
+      private
+
+      def eligible?(entry, text, available_gems_set)
+        return false if @loaded.include?(entry[:name])
+
+        triggers = entry[:triggers]
+        return false if triggers.nil? || triggers.empty?
+        return false unless triggers_match?(triggers, text)
+
+        gem_gate_pass?(entry[:gems], available_gems_set)
+      end
+
+      def triggers_match?(triggers, text)
+        triggers.any? { |t| text.include?(t.to_s.downcase) }
+      end
+
+      # Pass when:
+      #   - skill declares no gem dependencies, or
+      #   - we can't read a Gemfile (no project root / no Gemfile / parse error),
+      #     so we don't gate based on missing data, or
+      #   - every required gem is in the Gemfile.
+      def gem_gate_pass?(required_gems, available_gems_set)
+        return true if required_gems.nil? || required_gems.empty?
+        return true if available_gems_set.nil?
+
+        required_gems.all? { |g| available_gems_set.include?(g.to_s.downcase) }
+      end
+
+      def available_gems
+        return nil unless @project_root
+
+        gemfile = File.join(@project_root, 'Gemfile')
+        return nil unless File.exist?(gemfile)
+
+        GemfileParser.gems(File.read(gemfile)).to_set
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/rubyn_code/skills/pack_context.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require_relative 'gemfile_parser'
+require_relative 'registry_client'
+require_relative 'loader'
+require_relative 'catalog'
+
+module RubynCode
+  module Skills
+    # Builds additional skill context for PR reviews based on detected gems.
+    #
+    # On GitHub App runs (or any run where a Gemfile is present in the repo):
+    # 1. Parse the Gemfile for gem names
+    # 2. Fetch matching packs from the registry API
+    # 3. Format pack skills into a context block for the review agent
+    #
+    # The GitHub App has access to ALL packs as a premium differentiator.
+    # No local `/install-skills` required — everything is fetched transparently.
+    #
+    # Usage:
+    #   context = PackContext.for_repo(
+    #     project_root: '/path/to/repo',
+    #     registry_url: 'https://rubyn.ai'
+    #   )
+    #   review_prompt = context.build_review_context(diff_content)
+    class PackContext
+      SKILL_NAME_OVERRIDES = {
+        'stripe' => 'stripe/webhooks'
+      }.freeze
+
+      # Factory: build a PackContext for a given repo.
+      #
+      # @param project_root [String] path to the repository
+      # @param registry_url [String, nil] override for registry URL
+      # @return [PackContext] ready to build context
+      def self.for_repo(project_root:, registry_url: nil)
+        gemfile_path = File.join(project_root, 'Gemfile')
+        content = File.read(gemfile_path, encoding: 'UTF-8') if File.exist?(gemfile_path)
+        gems = content ? GemfileParser.gems(content) : []
+        client = RegistryClient.new(base_url: registry_url)
+        new(gems: gems, registry_client: client)
+      end
+
+      # Build context for an external/GitHub App context where we need to
+      # fetch the full pack content (not just local skills).
+      #
+      # @param pack_names [Array<String>] names of packs to load
+      # @return [String] context block to prepend to the review prompt
+      def self.for_packs(pack_names:, registry_client:)
+        new(gems: pack_names, registry_client: registry_client).build_context_block
+      end
+
+      attr_reader :gems
+
+      def initialize(gems:, registry_client:)
+        @gems = gems
+        @registry_client = registry_client
+        @cache = {}
+      end
+
+      # Returns the list of packs that matched detected gems.
+      # Some gems map to pack names (e.g. stripe → stripe/webhooks).
+      #
+      # Tradeoff: every detected gem that doesn't appear in SKILL_NAME_OVERRIDES
+      # is queried against the registry as a potential pack name. For a typical
+      # Rails app with 40-80 gems this means up to 80 sequential registry calls,
+      # each returning a 404 for unknown packs. This is intentional for now:
+      #   - Responses are cached in @cache so repeated calls within a session are free
+      #   - The GitHub App context is latency-tolerant (async review runs)
+      #   - A future batch endpoint on the registry API can reduce this to one call
+      # If latency becomes a problem, add a KNOWN_PACKS allowlist and skip gems
+      # that are not in it before fetching.
+      #
+      # @return [Array<String>] pack names
+      def matched_packs
+        @matched_packs ||= gems.filter_map { |gem| pack_name_for(gem) }.uniq
+      end
+
+      # Fetch and cache pack content from registry.
+      #
+      # RegistryClient#fetch_pack returns a { data:, etag:, not_modified: } wrapper.
+      # We cache and return only the :data payload so callers work with pack attributes
+      # directly (e.g. :description, :files) rather than the transport envelope.
+      #
+      # @param pack_name [String]
+      # @return [Hash, nil] pack data or nil if not found
+      def fetch_pack(pack_name)
+        return @cache[pack_name] if @cache.key?(pack_name)
+
+        result = @registry_client.fetch_pack(pack_name)
+        @cache[pack_name] = result[:data]
+      rescue RegistryError
+        @cache[pack_name] = nil
+      end
+
+      # Build a context block listing all detected packs and their skills.
+      # This is prepended to the review prompt so the agent can apply them.
+      #
+      # @return [String] context block
+      def build_context_block
+        return '' if matched_packs.empty?
+
+        lines = []
+        lines << "\n## Pack-Informed Review Context"
+        intro = 'The following skill packs were detected from the Gemfile and ' \
+                'are available for this review (via GitHub App access):'
+        lines << intro
+        lines << ''
+
+        matched_packs.each do |pack_name|
+          pack = fetch_pack(pack_name)
+          if pack.nil?
+            lines << "- **[#{pack_name}]** (pack not found in registry — skipped)"
+            next
+          end
+
+          lines << "### Pack: #{pack_name}"
+          lines << pack_description(pack)
+          lines << pack_skills(pack)
+          lines << ''
+        rescue StandardError
+          lines << "- **[#{pack_name}]** (failed to load — skipped)"
+        end
+
+        lines.join("\n")
+      end
+
+      private
+
+      def pack_name_for(gem)
+        SKILL_NAME_OVERRIDES[gem] || gem
+      end
+
+      def pack_description(pack)
+        desc = pack[:description] || pack['description'] || ''
+        desc.empty? ? '' : "#{desc}\n"
+      end
+
+      def pack_skills(pack)
+        files = pack[:files] || pack['files'] || []
+        return '' if files.empty?
+
+        # RegistryClient#fetch_files_with_content returns an Array of
+        # { filename: String, content: String } hashes — not a Hash keyed by name.
+        skills = files.map do |file|
+          filename = file[:filename] || file['filename'] || ''
+          skill_name = File.basename(filename, '.*')
+          skill_content = (file[:content] || file['content']).to_s
+          format_skill_block(skill_name, skill_content)
+        end
+        skills.join("\n")
+      end
+
+      def format_skill_block(name, content)
+        lines = []
+        lines << "<skill name=\"#{name}\">"
+        lines << content.strip
+        lines << '</skill>'
+        lines.join("\n")
+      end
+    end
+  end
+end