rubyn-code 0.4.0 → 0.5.0

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

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