rubyn-code 0.3.0 → 0.5.0

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

@@ -33,6 +33,31 @@ module RubynCode
         catalog.descriptions
       end
 
+      # Suggest skills based on what the codebase index reveals about the project.
+      #
+      # Inspects class names, parent classes, and file paths in the index to
+      # detect common Rails patterns (Devise, ActionMailer, ActiveJob, etc.)
+      # and returns matching skill names.
+      #
+      # @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
+        return [] unless codebase_index
+
+        suggestions = []
+        node_names = codebase_index.nodes.map { |n| n['name'].to_s }
+        node_files = codebase_index.nodes.map { |n| n['file'].to_s }
+
+        suggestions << 'authentication' if detect_devise?(node_names, node_files)
+        suggestions << 'mailer'         if detect_action_mailer?(node_names, node_files)
+        suggestions << 'background-job' if detect_active_job?(node_names, node_files)
+
+        suggestions
+      rescue StandardError
+        []
+      end
+
       private
 
       def format_skill(doc)
@@ -50,6 +75,24 @@ module RubynCode
             .gsub('>', '&gt;')
             .gsub('"', '&quot;')
       end
+
+      # Devise detection: look for Devise-related class names or config files.
+      def detect_devise?(node_names, node_files)
+        node_names.any? { |n| n.match?(/\bDevise\b/i) } ||
+          node_files.any? { |f| f.include?('devise') }
+      end
+
+      # ActionMailer detection: look for mailer classes or mailer directory.
+      def detect_action_mailer?(node_names, node_files)
+        node_names.any? { |n| n.match?(/Mailer\b/) } ||
+          node_files.any? { |f| f.include?('app/mailers/') }
+      end
+
+      # ActiveJob detection: look for job classes or jobs directory.
+      def detect_active_job?(node_names, node_files)
+        node_names.any? { |n| n.match?(/Job\b/) } ||
+          node_files.any? { |f| f.include?('app/jobs/') }
+      end
     end
   end
 end

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

data/lib/rubyn_code/skills/pack_installer.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+
+module RubynCode
+  module Skills
+    # Downloads and installs skill packs from the registry.
+    #
+    # Handles ETag caching, version comparison, and offline fallback.
+    # Installs to `.rubyn-code/skills/<pack>/` (project) by default,
+    # or `~/.rubyn-code/skills/<pack>/` with the --global flag.
+    class PackInstaller
+      MANIFEST_FILE = '.manifest.json'
+
+      # @param registry_client [RegistryClient]
+      # @param project_root [String] path to the project root
+      # @param global [Boolean] install to ~/.rubyn-code/skills/ instead of project
+      def initialize(registry_client:, project_root:, global: false)
+        @client = registry_client
+        @project_root = project_root
+        @global = global
+      end
+
+      # Install one or more packs by name.
+      #
+      # @param names [Array<String>] pack names
+      # @param update [Boolean] update without prompting if already installed
+      # @yield [event, data] progress events
+      # @yieldparam event [Symbol] :fetching, :downloading, :installed, :up_to_date, :error
+      # @yieldparam data [Hash] event-specific data
+      # @return [Array<Hash>] results per pack ({ name:, status:, files: })
+      def install(names, update: false, &block)
+        names.map { |name| install_single(name, update: update, &block) }
+      end
+
+      # Update all installed packs to their latest versions.
+      #
+      # @yield [event, data] progress events
+      # @return [Array<Hash>] results per pack
+      def update_all(&block)
+        installed = installed_packs
+        return [] if installed.empty?
+
+        installed.map { |pack| install_single(pack['name'], update: true, &block) }
+      end
+
+      # Remove an installed pack.
+      #
+      # @param name [String] pack name
+      # @return [Boolean] true if removed
+      def remove(name)
+        dir = pack_dir(name)
+        return false unless Dir.exist?(dir)
+
+        FileUtils.rm_rf(dir)
+        true
+      end
+
+      # List installed packs with their metadata.
+      #
+      # @return [Array<Hash>] installed pack manifests
+      def installed_packs
+        dir = skills_base_dir
+        return [] unless Dir.exist?(dir)
+
+        Dir.children(dir)
+           .select { |d| File.directory?(File.join(dir, d)) }
+           .filter_map { |d| read_manifest(d) }
+      end
+
+      # Check if a specific pack is installed.
+      #
+      # @param name [String]
+      # @return [Boolean]
+      def installed?(name)
+        File.exist?(manifest_path(name))
+      end
+
+      # Read the installed manifest for a pack.
+      #
+      # @param name [String]
+      # @return [Hash, nil]
+      def read_manifest(name)
+        path = manifest_path(name)
+        return nil unless File.exist?(path)
+
+        JSON.parse(File.read(path))
+      rescue JSON::ParserError
+        nil
+      end
+
+      private
+
+      def install_single(name, update: false)
+        yield(:fetching, { name: name }) if block_given?
+
+        pack_meta = @client.fetch_pack(name)
+        files = pack_meta['files'] || []
+
+        existing = read_manifest(name)
+        if existing && !update
+          if existing['version'] == pack_meta['version']
+            yield(:up_to_date, { name: name, version: pack_meta['version'] }) if block_given?
+            return { name: name, status: :up_to_date, files: [] }
+          end
+        end
+
+        etags = load_etags(name)
+        downloaded = download_files(name, files, etags)
+
+        yield(:downloading, { name: name, total: files.size, downloaded: downloaded.size }) if block_given?
+
+        write_manifest(name, pack_meta)
+        save_etags(name, etags)
+
+        yield(:installed, { name: name, version: pack_meta['version'], files: downloaded }) if block_given?
+
+        { name: name, status: :installed, files: downloaded }
+      rescue RegistryError => e
+        yield(:error, { name: name, message: e.message }) if block_given?
+        { name: name, status: :error, message: e.message }
+      end
+
+      def download_files(pack_name, files, etags)
+        dir = pack_dir(pack_name)
+        FileUtils.mkdir_p(dir)
+
+        downloaded = []
+
+        files.each do |file_info|
+          path = file_info['path']
+          result = @client.fetch_file(pack_name, path, etag: etags[path])
+
+          if result[:not_modified]
+            next
+          end
+
+          File.write(File.join(dir, path), result[:content])
+          etags[path] = result[:etag] if result[:etag]
+          downloaded << path
+        end
+
+        downloaded
+      end
+
+      def write_manifest(name, pack_meta)
+        manifest = {
+          'name' => pack_meta['name'],
+          'displayName' => pack_meta['displayName'],
+          'version' => pack_meta['version'],
+          'installedAt' => Time.now.utc.iso8601,
+          'skillCount' => (pack_meta['files'] || []).size,
+          'files' => (pack_meta['files'] || []).map { |f| f['path'] }
+        }
+
+        File.write(manifest_path(name), JSON.pretty_generate(manifest))
+      end
+
+      def load_etags(name)
+        path = etags_path(name)
+        return {} unless File.exist?(path)
+
+        JSON.parse(File.read(path))
+      rescue JSON::ParserError
+        {}
+      end
+
+      def save_etags(name, etags)
+        File.write(etags_path(name), JSON.pretty_generate(etags))
+      end
+
+      def pack_dir(name)
+        File.join(skills_base_dir, name)
+      end
+
+      def manifest_path(name)
+        File.join(pack_dir(name), MANIFEST_FILE)
+      end
+
+      def etags_path(name)
+        File.join(pack_dir(name), '.etags.json')
+      end
+
+      def skills_base_dir
+        if @global
+          File.join(Config::Defaults::HOME_DIR, 'skills')
+        else
+          File.join(@project_root, '.rubyn-code', 'skills')
+        end
+      end
+    end
+  end
+end