ruby_llm-skills 0.3.0 → 0.5.0.pre1

data/lib/ruby_llm/skills/marketplace/registry.rb

@@ -0,0 +1,384 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "securerandom"
+
+module RubyLLM
+  module Skills
+    module Marketplace
+      # The public surface: marketplaces recorded in a lockfile, their plugins
+      # installed under a root directory, and a loader over what is installed.
+      #
+      # @example
+      #   marketplaces = RubyLLM::Skills.marketplaces           # vendor/skills + skills.lock.json
+      #   marketplaces.add("EveryInc/compound-writing")          # follows the default branch
+      #   marketplaces.add("typesafe-ai/skills", ref: "v0.5.7")  # pinned to a tag
+      #   marketplaces.plugins("compound-writing").map(&:name)
+      #   marketplaces.install("compound-writing")               # every supported plugin
+      #   marketplaces.install("typesafe-ai", only: ["typesafe"])
+      #   marketplaces.install                                   # reproduce the lockfile
+      #   marketplaces.update                                    # move every unpinned ref forward
+      #   marketplaces.remove("typesafe-ai")
+      #   chat.with_skills(marketplaces)
+      #
+      class Registry
+        SCRATCH_PREFIX = ".building-"
+
+        # One recorded marketplace.
+        Record = Data.define(:name, :source, :commit, :plugins) do
+          def kind = source.kind
+
+          def locator = source.locator
+
+          def ref = source.ref
+
+          def pinned? = source.pinned?
+
+          def plugin_names = plugins.keys
+        end
+
+        # One installed plugin.
+        InstalledPlugin = Data.define(:marketplace, :name, :version, :version_kind, :commit, :tree_sha256, :source, :skills, :path) do
+          def skills_path
+            File.join(path, "skills")
+          end
+
+          def to_s
+            "#{marketplace}/#{name}"
+          end
+        end
+
+        # What an install or update did, keyed by "marketplace/plugin".
+        Result = Data.define(:installed, :updated, :unchanged, :skipped, :errors) do
+          def self.empty
+            new(installed: [], updated: [], unchanged: [], skipped: {}, errors: {})
+          end
+
+          def success? = errors.empty?
+
+          def changed = installed + updated
+        end
+
+        attr_reader :root, :lockfile_path
+
+        # @param root [String] where plugins are written (default: Marketplace.root)
+        # @param lockfile [String] the lockfile path (default: Marketplace.lockfile)
+        def initialize(root: Marketplace.root, lockfile: Marketplace.lockfile)
+          @root = File.expand_path(root.to_s)
+          @lockfile_path = File.expand_path(lockfile.to_s)
+        end
+
+        # Records a marketplace and caches its marketplace file; installs nothing.
+        #
+        # @param locator [String] `owner/repo`, `owner/repo@ref`, a repository URL, a hosted `.json` URL, or a directory
+        # @param ref [String, nil] a branch, tag or commit sha to pin the marketplace to
+        # @param as [String, nil] the name to record it under (default: the marketplace file's `name`)
+        # @return [Record]
+        # @raise [FetchError, InvalidManifestError, ArgumentError]
+        def add(locator, ref: nil, as: nil)
+          source = Locator.parse(locator, ref: ref)
+          fetcher = Fetcher.for(source)
+          head = fetcher.head
+          files = fetcher.catalog_files(head)
+          catalog = Manifest.discover(files)
+          name = Manifest.presence(as) || catalog.name
+          raise ArgumentError, "#{name.inspect} is not a valid marketplace name" unless name.match?(Manifest::NAME_PATTERN)
+
+          existing = lockfile.marketplace(name)
+          if existing && Locator::Source.from_h(existing) != source
+            raise ArgumentError, "a marketplace named #{name.inspect} is already added from #{Locator::Source.from_h(existing)}; pass as: to add this one under another name"
+          end
+
+          cache_catalog!(name, files)
+          lockfile.set_marketplace(name, source.to_h.merge("commit" => head.sha))
+          lockfile.save
+          reload!
+          find(name)
+        end
+
+        # @return [Array<Record>] every recorded marketplace
+        def list
+          lockfile.names.map { |name| record(name) }
+        end
+
+        # @return [Record, nil]
+        def find(name)
+          lockfile.marketplace(name) && record(name)
+        end
+
+        # @return [Record]
+        # @raise [NotFoundError]
+        def fetch(name)
+          find(name) || raise(NotFoundError, "Marketplace not found: #{name}")
+        end
+
+        # The plugins a marketplace lists, from the cached marketplace file.
+        #
+        # @return [Array<Manifest::Entry>]
+        def plugins(name)
+          catalog(fetch(name)).plugins
+        end
+
+        # Installs plugins. With a marketplace name, every supported plugin of
+        # that marketplace (or +only+ the named ones) at the marketplace's
+        # recorded commit. With no name, every plugin in the lockfile at its
+        # recorded commit, so a fresh checkout reproduces the same trees.
+        #
+        # @return [Result]
+        # @raise [NotFoundError] for an unknown marketplace or plugin name
+        def install(name = nil, only: nil)
+          result = Result.empty
+          if name.nil?
+            list.each { |record| install_plugins(record, record.plugin_names, result, reproduce: true) }
+          else
+            record = fetch(name)
+            wanted = only ? Array(only).map(&:to_s) : supported_plugin_names(record)
+            install_plugins(record, wanted, result, reproduce: false)
+          end
+          finish(result)
+        end
+
+        # Moves marketplaces forward: re-resolves each ref, re-reads the
+        # marketplace file when the head moved, refetches installed plugins
+        # whose source moved, and rewrites the lockfile. A marketplace pinned
+        # to a commit never moves.
+        #
+        # @return [Result]
+        def update(name = nil, only: nil)
+          result = Result.empty
+          records = name ? [fetch(name)] : list
+          records.each do |record|
+            record = refresh_head!(record)
+            wanted = only ? Array(only).map(&:to_s) : record.plugin_names
+            install_plugins(record, wanted, result, reproduce: false)
+          end
+          finish(result)
+        end
+
+        # Deletes a marketplace's directory and lockfile entry.
+        def remove(name)
+          record = fetch(name)
+          FileUtils.rm_rf(marketplace_dir(record.name))
+          lockfile.delete_marketplace(record.name)
+          lockfile.save
+          reload!
+          record
+        end
+
+        # Deletes one plugin's directory and lockfile entry.
+        def uninstall(name, plugin)
+          record = fetch(name)
+          installed = record.plugins[plugin.to_s] || raise(NotFoundError, "Plugin not installed: #{name}/#{plugin}")
+          FileUtils.rm_rf(installed.path)
+          lockfile.delete_plugin(record.name, plugin)
+          lockfile.save
+          reload!
+          installed
+        end
+
+        # @return [Array<InstalledPlugin>] in lockfile order
+        def installed
+          list.flat_map { |record| record.plugins.values }
+        end
+
+        # A loader over every installed plugin's skills.
+        #
+        # @return [Loader]
+        def loader
+          loaders = installed.map { |plugin| FilesystemLoader.new(plugin.skills_path) }
+          (loaders.length == 1) ? loaders.first : RubyLLM::Skills.compose(*loaders)
+        end
+
+        # Forget the cached lockfile so the next call re-reads it.
+        def reload!
+          @lockfile = nil
+          self
+        end
+
+        def inspect
+          "#<#{self.class.name} root=#{root.inspect} lockfile=#{lockfile_path.inspect}>"
+        end
+
+        private
+
+        def lockfile
+          @lockfile ||= Lockfile.load(lockfile_path)
+        end
+
+        def finish(result)
+          lockfile.save
+          reload!
+          result
+        end
+
+        def record(name)
+          data = lockfile.marketplace(name)
+          source = Locator::Source.from_h(data)
+          plugins = lockfile.plugins(name).sort.to_h do |plugin_name, plugin|
+            [plugin_name, installed_plugin(name, plugin_name, plugin)]
+          end
+          Record.new(name: name, source: source, commit: data["commit"], plugins: plugins)
+        end
+
+        def installed_plugin(marketplace, plugin_name, data)
+          InstalledPlugin.new(marketplace: marketplace, name: plugin_name, version: data["version"], version_kind: data["version_kind"],
+            commit: data["commit"], tree_sha256: data["tree_sha256"], source: Manifest::PluginSource.from_h(data["source"] || {}),
+            skills: Array(data["skills"]), path: plugin_dir(marketplace, plugin_name))
+        end
+
+        def marketplace_dir(name)
+          File.join(root, safe_name(name))
+        end
+
+        def plugin_dir(marketplace, plugin)
+          File.join(marketplace_dir(marketplace), safe_name(plugin))
+        end
+
+        # Names come from marketplace files and the lockfile; only a kebab-case
+        # name may become a directory under the root.
+        def safe_name(name)
+          raise LockfileError, "unsafe name #{name.inspect}" unless name.to_s.match?(Manifest::NAME_PATTERN)
+
+          name.to_s
+        end
+
+        def cache_catalog!(name, files)
+          dir = marketplace_dir(name)
+          Manifest::PATHS.each { |path| FileUtils.rm_f(File.join(dir, path)) }
+          Tarball.write_directory(files, dir)
+        end
+
+        def catalog(record)
+          dir = marketplace_dir(record.name)
+          files = Manifest::PATHS.each_with_object({}) do |path, found|
+            full = File.join(dir, path)
+            found[path] = File.binread(full) if File.file?(full)
+          end
+          return Manifest.discover(files) unless files.empty?
+
+          fetcher = Fetcher.for(record.source)
+          head = recorded_head(record)
+          files = fetcher.catalog_files(head)
+          cache_catalog!(record.name, files)
+          Manifest.discover(files)
+        end
+
+        def supported_plugin_names(record)
+          catalog(record).plugins.select(&:supported?).map(&:name)
+        end
+
+        # Re-resolves the ref; on a move, re-reads and caches the marketplace file.
+        def refresh_head!(record)
+          fetcher = Fetcher.for(record.source)
+          head = fetcher.head(previous_sha: record.commit)
+          return record if head.unchanged? && catalog_cached?(record)
+
+          cache_catalog!(record.name, fetcher.catalog_files(head))
+          lockfile.set_marketplace(record.name, record.source.to_h.merge("commit" => head.sha))
+          Record.new(name: record.name, source: record.source, commit: head.sha, plugins: record.plugins)
+        end
+
+        def catalog_cached?(record)
+          Manifest::PATHS.any? { |path| File.file?(File.join(marketplace_dir(record.name), path)) }
+        end
+
+        # A Head standing at the recorded commit, so relative sources read the
+        # marketplace tree exactly as it was recorded. A directory marketplace
+        # has no history: its head is what the folder holds now.
+        def recorded_head(record)
+          fetcher = Fetcher.for(record.source)
+          return fetcher.head if record.kind == "directory" || record.commit.nil?
+
+          Fetcher::Head.new(sha: record.commit, etag: nil, unchanged: true)
+        end
+
+        def install_plugins(record, names, result, reproduce:)
+          return if names.empty?
+
+          catalog = self.catalog(record)
+          unknown = names.reject { |plugin_name| catalog.plugin(plugin_name) || record.plugins[plugin_name] }
+          raise NotFoundError, "Plugin not found in #{record.name}: #{unknown.join(", ")}" if unknown.any?
+
+          fetcher = Fetcher.for(record.source)
+          head = recorded_head(record)
+          names.each do |plugin_name|
+            key = "#{record.name}/#{plugin_name}"
+            installed = record.plugins[plugin_name]
+            entry = catalog.plugin(plugin_name)
+            next result.errors[key] = "no longer listed by the marketplace" if entry.nil?
+            next result.skipped[key] = "unsupported source (#{entry.source.reason})" unless entry.supported?
+            next result.skipped[key] = "relative sources are not available from a hosted marketplace.json" if record.kind == "url" && entry.source.kind == "relative"
+
+            install_plugin(record, fetcher, head, entry, installed, result, reproduce: reproduce)
+          rescue FetchError, InvalidPluginError, InvalidManifestError => e
+            result.errors[key] = e.message
+          end
+        end
+
+        def install_plugin(record, fetcher, head, entry, installed, result, reproduce:)
+          key = "#{record.name}/#{entry.name}"
+          plugin_source = (reproduce && installed) ? pin_source(entry.source, installed) : entry.source
+          sha = fetcher.source_sha(plugin_source, head: head)
+          if installed && sha && sha == installed.commit && on_disk?(installed)
+            return result.unchanged << key
+          end
+
+          fetched = fetcher.source_tree(plugin_source, head: head)
+          if reproduce && installed && plugin_source.kind == "archive" && fetched.sha != installed.commit
+            raise FetchError, "#{key}: archive digest #{fetched.sha[0, 12]} does not match the lockfile's #{installed.commit.to_s[0, 12]}"
+          end
+
+          bundle = Bundle.new(fetched.files, entry: entry)
+          return result.skipped[key] = "no skills, commands or agents to install" if bundle.empty?
+          if installed && installed.tree_sha256 == bundle.tree_sha256 && on_disk?(installed)
+            lockfile.set_plugin(record.name, entry.name, plugin_data(entry, fetched, bundle))
+            return result.unchanged << key
+          end
+
+          target = plugin_dir(record.name, entry.name)
+          was_on_disk = File.directory?(target)
+          write_tree!(target, bundle)
+          lockfile.set_plugin(record.name, entry.name, plugin_data(entry, fetched, bundle))
+          (was_on_disk ? result.updated : result.installed) << key
+        end
+
+        # The lockfile's commit, so a reproduce fetches what was recorded rather than the ref's current head.
+        def pin_source(plugin_source, installed)
+          return plugin_source unless %w[github gitlab].include?(plugin_source.kind) && installed.commit
+
+          plugin_source.with(sha: installed.commit)
+        end
+
+        def on_disk?(installed)
+          dir = installed.path
+          File.directory?(dir) && Tarball.tree_sha256(Tarball.from_directory(dir)) == installed.tree_sha256
+        end
+
+        def plugin_data(entry, fetched, bundle)
+          version, kind = if bundle.version
+            [bundle.version, bundle.version_kind]
+          else
+            [fetched.sha, (entry.source.kind == "archive") ? "archive" : "commit"]
+          end
+          {"version" => version, "version_kind" => kind, "commit" => fetched.sha, "tree_sha256" => bundle.tree_sha256,
+           "source" => entry.source.to_h, "skills" => bundle.skill_names}
+        end
+
+        # Written to a scratch directory beside the target and moved into
+        # place with one rename, so a failure leaves no partial tree.
+        def write_tree!(target, bundle)
+          FileUtils.mkdir_p(File.dirname(target))
+          scratch = File.join(File.dirname(target), "#{SCRATCH_PREFIX}#{File.basename(target)}-#{SecureRandom.hex(4)}")
+          FileUtils.mkdir_p(scratch)
+          Tarball.write_directory(bundle.tree, scratch)
+          FileUtils.rm_rf(target)
+          File.rename(scratch, target)
+          target
+        rescue
+          FileUtils.rm_rf(scratch) if scratch && File.exist?(scratch)
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/skills/marketplace/tarball.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "rubygems/package"
+require "zlib"
+require "stringio"
+require "digest"
+require "fileutils"
+require "pathname"
+
+module RubyLLM
+  module Skills
+    module Marketplace
+      # The one tar.gz reader for upstream content: every entry path is
+      # cleaned and refused when it escapes (`..`, absolute); anything but a
+      # regular file or directory (symlinks, hardlinks, devices, FIFOs) is
+      # dropped, never followed or written; the archive, each file and the
+      # file count are capped. GitHub and GitLab archives wrap the repository
+      # in one root directory, which +strip_root+ removes.
+      #
+      # Trees are plain hashes of `"relative/path" => bytes`.
+      #
+      module Tarball
+        REGULAR = ["0", "\0"].freeze
+        DIRECTORY = "5"
+        EXTENDED_HEADERS = %w[g x].freeze
+
+        class << self
+          # @param archive [String] tar.gz bytes
+          # @param strip_root [Boolean] drop the single wrapping directory
+          # @param subdir [String, nil] keep only this directory, re-rooted
+          # @return [Hash{String => String}] the files
+          # @raise [InvalidPluginError]
+          def read(archive, strip_root: true, subdir: nil, max_bytes: config.max_archive_bytes,
+            max_file_bytes: config.max_file_bytes, max_files: config.max_files)
+            raise InvalidPluginError, "archive is empty" if archive.to_s.empty?
+            raise InvalidPluginError, "archive exceeds #{max_bytes} bytes" if archive.bytesize > max_bytes
+
+            files = {}
+            total = 0
+            root = nil
+            prefix = clean_prefix(subdir)
+            Zlib::GzipReader.wrap(StringIO.new(archive)) do |gz|
+              Gem::Package::TarReader.new(gz) do |tar|
+                tar.each do |entry|
+                  typeflag = entry.header.typeflag
+                  next if EXTENDED_HEADERS.include?(typeflag)
+
+                  parts = clean_path(entry.full_name).split("/")
+                  if strip_root
+                    root ||= parts.first
+                    raise InvalidPluginError, "archive has more than one root (#{root.inspect}, #{parts.first.inspect})" unless parts.first == root
+
+                    parts = parts.drop(1)
+                  end
+                  next if typeflag == DIRECTORY || entry.directory?
+                  next unless REGULAR.include?(typeflag) || entry.file?
+                  next if parts.empty?
+
+                  rel = parts.join("/")
+                  unless prefix.empty?
+                    next unless rel.start_with?("#{prefix}/")
+
+                    rel = rel.delete_prefix("#{prefix}/")
+                  end
+                  raise InvalidPluginError, "archive file #{entry.full_name.inspect} exceeds #{max_file_bytes} bytes" if entry.size > max_file_bytes
+                  raise InvalidPluginError, "archive has more than #{max_files} files" if files.size >= max_files
+                  raise InvalidPluginError, "archive expands past #{max_bytes} bytes" if (total += entry.size) > max_bytes
+
+                  files[rel] = entry.read.to_s.b
+                end
+              end
+            end
+            raise InvalidPluginError, "archive has no files#{" under #{prefix}" unless prefix.empty?}" if files.empty?
+
+            files
+          rescue Zlib::Error, Gem::Package::TarInvalidError => e
+            raise InvalidPluginError, "archive is not a valid tar.gz (#{e.class.name.split("::").last})"
+          end
+
+          # `..`, absolute paths, empty names and NUL bytes are refused before
+          # any path is joined to a directory.
+          def clean_path(name)
+            raw = name.to_s.strip
+            raise InvalidPluginError, "unsafe archive path #{name.inspect}" if raw.empty? || raw.include?("\0") || raw.start_with?("/") || raw.include?("\\")
+
+            cleaned = Pathname.new(raw).cleanpath.to_s
+            raise InvalidPluginError, "unsafe archive path #{name.inspect}" if cleaned.empty? || cleaned == "." || cleaned == ".." || cleaned.start_with?("../", "/")
+
+            cleaned
+          end
+
+          # `{ "path" => bytes }` to tar.gz bytes, entries sorted and the
+          # mtime zeroed so the same tree always yields the same archive.
+          def write(files, root: nil)
+            io = StringIO.new
+            Zlib::GzipWriter.wrap(io) do |gz|
+              gz.mtime = 0
+              Gem::Package::TarWriter.new(gz) do |tar|
+                files.sort.each do |path, data|
+                  full = root ? "#{root}/#{path}" : path
+                  bytes = data.to_s.b
+                  tar.add_file_simple(full, 0o644, bytes.bytesize) { |f| f.write(bytes) }
+                end
+              end
+            end
+            io.string
+          end
+
+          # The directory as `{ "path" => bytes }` (regular files only).
+          def from_directory(dir, max_bytes: config.max_archive_bytes, max_file_bytes: config.max_file_bytes, max_files: config.max_files)
+            base = Pathname.new(dir)
+            files = {}
+            total = 0
+            Dir.glob("**/*", File::FNM_DOTMATCH, base: base.to_s).sort.each do |rel|
+              next if rel == "." || rel.end_with?("/.") || rel.split("/").include?("..")
+
+              full = base.join(rel)
+              next if full.symlink? || !full.file?
+              raise InvalidPluginError, "#{rel} exceeds #{max_file_bytes} bytes" if full.size > max_file_bytes
+              raise InvalidPluginError, "#{dir} has more than #{max_files} files" if files.size >= max_files
+              raise InvalidPluginError, "#{dir} holds more than #{max_bytes} bytes" if (total += full.size) > max_bytes
+
+              files[rel] = full.binread
+            end
+            files
+          end
+
+          # Writes the tree under +dir+, creating parents; replaces nothing else.
+          def write_directory(files, dir)
+            files.each do |path, data|
+              target = File.join(dir, path)
+              FileUtils.mkdir_p(File.dirname(target))
+              File.binwrite(target, data)
+            end
+            dir
+          end
+
+          # sha256 over the sorted paths and content hashes: the tree's identity.
+          def tree_sha256(files)
+            digest = Digest::SHA256.new
+            files.sort.each do |path, data|
+              digest << path << "\0" << Digest::SHA256.hexdigest(data.to_s) << "\n"
+            end
+            digest.hexdigest
+          end
+
+          private
+
+          def config
+            Marketplace.config
+          end
+
+          def clean_prefix(subdir)
+            subdir.to_s.delete_prefix("./").delete_suffix("/")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/skills/marketplace.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "marketplace/config"
+require_relative "marketplace/http"
+require_relative "marketplace/tarball"
+require_relative "marketplace/manifest"
+require_relative "marketplace/locator"
+require_relative "marketplace/github_repo"
+require_relative "marketplace/gitlab_repo"
+require_relative "marketplace/fetcher"
+require_relative "marketplace/bundle"
+require_relative "marketplace/lockfile"
+require_relative "marketplace/registry"
+
+module RubyLLM
+  module Skills
+    # Plugin marketplaces as a skill source.
+    #
+    # A marketplace is a Claude Code, Codex, or Cursor plugin marketplace
+    # (a GitHub repository, GitLab project, hosted marketplace.json, or a
+    # local directory). Its plugins are fetched over HTTPS, normalized into
+    # the skills/ layout the loaders read, written under a vendor directory,
+    # and recorded in a lockfile with their resolved commit and version.
+    #
+    # @example
+    #   marketplaces = RubyLLM::Skills.marketplaces
+    #   marketplaces.add("EveryInc/compound-writing")
+    #   marketplaces.install("compound-writing")
+    #   chat.with_skills(marketplaces)
+    #
+    module Marketplace
+      # Base error for the marketplace layer.
+      class Error < Skills::Error; end
+
+      # Raised when an upstream cannot be reached or refuses the request.
+      class FetchError < Error; end
+
+      # Raised when a marketplace file is malformed.
+      class InvalidManifestError < Error; end
+
+      # Raised when a plugin's tree breaks the Agent Skills rules or the caps.
+      class InvalidPluginError < Error; end
+
+      # Raised when the lockfile cannot be read.
+      class LockfileError < Error; end
+
+      DEFAULT_ROOT = "vendor/skills"
+      DEFAULT_LOCKFILE = "skills.lock.json"
+
+      class << self
+        attr_writer :root, :lockfile
+
+        # Where installed plugins live (default: vendor/skills).
+        def root
+          @root || DEFAULT_ROOT
+        end
+
+        # Where the lockfile lives (default: skills.lock.json).
+        def lockfile
+          @lockfile || DEFAULT_LOCKFILE
+        end
+
+        def config
+          @config ||= Config.new
+        end
+
+        # @yield [Config] the configuration to change
+        def configure
+          yield config
+          config
+        end
+
+        def reset_config!
+          @config = Config.new
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/skills/railtie.rb

@@ -10,6 +10,8 @@ module RubyLLM
     class Railtie < ::Rails::Railtie
       initializer "ruby_llm_skills.configure" do
         RubyLLM::Skills.default_path = Rails.root.join("app", "skills").to_s
+        RubyLLM::Skills::Marketplace.root = Rails.root.join(RubyLLM::Skills::Marketplace::DEFAULT_ROOT).to_s
+        RubyLLM::Skills::Marketplace.lockfile = Rails.root.join(RubyLLM::Skills::Marketplace::DEFAULT_LOCKFILE).to_s
       end
 
       # Add app/skills to autoload paths (before initialization)
@@ -32,6 +34,7 @@ module RubyLLM
       # Provide rake tasks
       rake_tasks do
         load File.expand_path("tasks/skills.rake", __dir__)
+        load File.expand_path("tasks/marketplaces.rake", __dir__)
       end
     end
   end

data/lib/ruby_llm/skills/skill_tool.rb

@@ -27,15 +27,22 @@ module RubyLLM
     #
     class SkillTool < RubyLLM::Tool
       description "Execute a skill within the main conversation."
-      param :command, type: "string",
-        desc: "The skill name (e.g., 'pdf' or 'write-poem')"
-      param :arguments, type: "string", required: false,
-        desc: "Arguments passed after the command (e.g., '/write-poem about robots' passes 'about robots')"
-      param :resource, type: "string", required: false,
-        desc: "Optional resource path to load (e.g., 'scripts/helper.rb', 'references/guide.md')"
+      parameter :command, type: "string",
+        description: "The skill name (e.g., 'pdf' or 'write-poem')"
+      parameter :arguments, type: "string", required: false,
+        description: "Arguments passed after the command (e.g., '/write-poem about robots' passes 'about robots')"
+      parameter :resource, type: "string", required: false,
+        description: "Optional resource path to load (e.g., 'scripts/helper.rb', 'references/guide.md')"
 
       attr_reader :loader
 
+      # Tool name for RubyLLM.
+      #
+      # @return [String] "skill"
+      def self.tool_name
+        "skill"
+      end
+
       # Initialize with a skill loader.
       #
       # @param loader [Loader] any loader (FilesystemLoader, ZipLoader, etc.)
@@ -43,13 +50,6 @@ module RubyLLM
         @loader = loader
       end
 
-      # Tool name for RubyLLM.
-      #
-      # @return [String] "skill"
-      def name
-        "skill"
-      end
-
       # Dynamic description including available skills.
       #
       # @return [String] tool description with embedded skill metadata
@@ -98,7 +98,7 @@ module RubyLLM
         {
           name: name,
           description: description,
-          parameters: params_schema
+          parameters: parameters_schema
         }
       end