rubyn-code 0.3.0 → 0.5.0

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/tasks/models.rb

@@ -10,6 +10,7 @@ module RubynCode
       def in_progress? = status == 'in_progress'
       def completed? = status == 'completed'
       def blocked? = status == 'blocked'
+      def failed? = status == 'failed'
 
       def to_h
         {

data/lib/rubyn_code/tools/base.rb

@@ -37,6 +37,19 @@ module RubynCode
             input_schema: Schema.build(parameters)
           }
         end
+
+        # One-line summary of a successful invocation, shown in the IDE's
+        # chat card. Default is empty so the UI renders a clean "Done"
+        # indicator. Override in subclasses that have a useful one-liner
+        # (e.g. "Edited app.rb (1 replacement)"). The full output still
+        # goes to the conversation untouched — this only affects the UI.
+        #
+        # @param output [String] what execute(**) returned
+        # @param args   [Hash]   the tool arguments (string-keyed)
+        # @return [String]
+        def summarize(_output, _args)
+          ''
+        end
       end
 
       attr_reader :project_root

data/lib/rubyn_code/tools/bash.rb

@@ -18,6 +18,11 @@ module RubynCode
       RISK_LEVEL = :execute
       REQUIRES_CONFIRMATION = true
 
+      def self.summarize(_output, args)
+        cmd = args['command'] || args[:command] || ''
+        "$ #{cmd[0, 180]}"
+      end
+
       def execute(command:, timeout: 120)
         validate_command!(command)