pikuri-skills 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3225ec6dbaa280bbb0ca84df6207a4d3c08030b80c0ad6246ed72c164a1bf80d
+  data.tar.gz: 4605f1727c2c11223798f6a10dbe6b1e46ccbabcb5d874a4a935fa8897e45ab9
+SHA512:
+  metadata.gz: 7eb4aaf9b73614909760697e9645d290cb9c752205b3cb05a2e6a340cc41281e79f55d4c80f9bbd22beea48f200b8503000801f14f94964b0a974bd2c8cd4f94
+  data.tar.gz: 4dca2734c9ac979a6b8f4d9e79c1bc2a5390046cd2fabe647e348e22233391647741d3073a7f4260717051f409599d36b418c69ec7925787353780e80429aa31

data/README.md

@@ -0,0 +1,40 @@
+# pikuri-skills
+
+[Agent Skills standard](https://agentskills.io/specification)
+support for the [pikuri](https://codeberg.org/mvysny/pikuri)
+AI-assistant toolkit.
+
+Provides:
+- `Pikuri::Skill::Catalog` — discovery + validation of skill folders
+  under `.pikuri/skills`, `.claude/skills`, `.agents/skills` (project
+  + global). Walks from CWD up to the git root.
+- `Pikuri::Skill::SkillTool` — the loading tool the LLM uses to pull
+  a skill's body into the conversation on demand.
+- `Pikuri::Skill::Extension` — wires both into a `Pikuri::Agent` via
+  the `c.add_extension(...)` block API.
+
+## Install
+
+```ruby
+# Gemfile
+gem 'pikuri-skills'
+```
+
+## Usage
+
+```ruby
+require 'pikuri-core'
+require 'pikuri-skills'
+
+catalog = Pikuri::Skill::Catalog::Bundled.discover(cwd: Dir.pwd)
+
+agent = Pikuri::Agent.new(transport: ..., system_prompt: ...) do |c|
+  c.add_extension(Pikuri::Skill::Extension.new(catalog: catalog))
+end
+```
+
+When the catalog is non-empty, the extension's `configure` appends
+`<available_skills>` to the system prompt (listing every discovered
+skill) and registers the `skill` tool. The LLM invokes `skill` with a
+name; the tool returns the skill's body wrapped with its base
+directory so the LLM can resolve sidecar files via `read`.

data/lib/pikuri/skill/catalog.rb

@@ -0,0 +1,375 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Pikuri
+  module Skill
+    # Discovery + validation of *skills* — Markdown files with YAML
+    # frontmatter that the agent loads on demand via {Tool}.
+    #
+    # A skill is a directory containing a +SKILL.md+ file. The frontmatter
+    # declares the skill's +name+ and +description+; everything in the
+    # directory (helper scripts, reference notes, templates) is treated as
+    # sidecar content the LLM can pull in via the regular +read+ tool
+    # after loading the skill. Pikuri implements the
+    # {https://agentskills.io/specification Agent Skills standard}
+    # leniently — invalid frontmatter is warned about but the skill
+    # still loads, except a missing +description+ which is fatal (no
+    # description means the LLM has no signal for when to invoke it).
+    #
+    # == Catalog vs. tool
+    #
+    # {Catalog} owns the *discovery* layer: where skills live, how the
+    # frontmatter is parsed, what wins on a name collision. The
+    # {Tool} class is the *loading* layer: it receives a catalog at
+    # construction and looks names up against it when the LLM invokes
+    # +skill+. The two are paired by {Extension} — non-empty catalog ⇒
+    # {Tool} is appended to the agent's tool list and the catalog's
+    # prompt block is appended to the system prompt.
+    #
+    # == The seam
+    #
+    # {Catalog} is an abstract base with two bundled implementations:
+    # {Empty} (the +EMPTY+ singleton, used by +pikuri-chat+ and as the
+    # default for any caller that doesn't have a filesystem story) and
+    # {Bundled} (the on-disk scanner). The seam lets future hosts (e.g.
+    # an in-editor pikuri reading skills from a virtual filesystem, or
+    # a synthetic test catalog) swap in without touching {Tool} or
+    # {Extension}.
+    class Catalog
+      # Frontmatter +name+ cap per the Agent Skills standard.
+      MAX_NAME_LENGTH = 64
+
+      # Frontmatter +description+ cap per the Agent Skills standard.
+      MAX_DESCRIPTION_LENGTH = 1024
+
+      # The three skill directories pikuri scans, in precedence order.
+      # +.pikuri+ first (the user's own pikuri-specific skills),
+      # +.claude+ second (so existing Claude Code skills travel along
+      # for free), +.agents+ last (the cross-harness convention PI also
+      # honors). Same names are used for both global roots
+      # (under +~/+) and project roots (relative to CWD, walked up).
+      SKILL_DIR_NAMES = ['.pikuri/skills', '.claude/skills', '.agents/skills'].freeze
+
+      LOGGER = Pikuri.logger_for('Skills')
+      private_constant :LOGGER
+
+      # A loaded skill record. Holds everything the catalog discovers
+      # and the tool needs to satisfy a load: +name+ and +description+
+      # for the catalog's prompt block, +location+ (absolute path to
+      # the +SKILL.md+) so the LLM can reference sidecars relative to
+      # +File.dirname(location)+, and +body+ (the SKILL.md content
+      # below the frontmatter) returned verbatim when the tool fires.
+      #
+      # Bodies are eager-loaded at scan time even though only
+      # +name+/+description+/+location+ end up in the prompt — skill
+      # files are small, eager loading keeps the tool's hot path
+      # IO-free, and there is no fault tolerance requirement that
+      # warrants the complexity of lazy I/O.
+      Skill = Data.define(:name, :description, :location, :body)
+
+      # Skills available to the LLM, in stable insertion order (which
+      # equals the order they were discovered, which equals precedence).
+      #
+      # @return [Array<Skill>]
+      # @raise [NotImplementedError] in the abstract base
+      def list
+        raise NotImplementedError, "#{self.class}#list must be implemented"
+      end
+
+      # Look up a skill by name.
+      #
+      # @param name [String]
+      # @return [Skill, nil]
+      # @raise [NotImplementedError] in the abstract base
+      def get(name)
+        raise NotImplementedError, "#{self.class}#get must be implemented"
+      end
+
+      # @return [Boolean] true when {#list} is empty. {Extension}
+      #   keys its auto-wiring (system-prompt augmentation + {Tool}
+      #   registration) off this — empty catalog ⇒ no surface change.
+      def empty?
+        list.empty?
+      end
+
+      # System-prompt block advertising every loaded skill to the LLM.
+      # Follows the Agent Skills standard's XML shape (PI uses the same
+      # one) so a skill folder authored against any compliant harness
+      # renders consistently here.
+      #
+      # Returns +""+ for an empty catalog so callers can unconditionally
+      # concatenate without an +if+. The leading +\n\n+ separates the
+      # block from whatever the caller's static system prompt ends with.
+      #
+      # @return [String]
+      def format_for_prompt
+        return '' if empty?
+
+        lines = [
+          '',
+          '',
+          'The following skills provide specialized instructions for specific tasks.',
+          "Use the `skill` tool with the skill's name to load its full instructions.",
+          '',
+          '<available_skills>'
+        ]
+        list.each do |skill|
+          lines << '  <skill>'
+          lines << "    <name>#{escape_xml(skill.name)}</name>"
+          lines << "    <description>#{escape_xml(skill.description)}</description>"
+          lines << "    <location>#{escape_xml(skill.location)}</location>"
+          lines << '  </skill>'
+        end
+        lines << '</available_skills>'
+        lines.join("\n")
+      end
+
+      private
+
+      def escape_xml(str)
+        str.gsub('&', '&amp;')
+           .gsub('<', '&lt;')
+           .gsub('>', '&gt;')
+           .gsub('"', '&quot;')
+           .gsub("'", '&apos;')
+      end
+
+      # Null-object catalog. The +EMPTY+ constant is the singleton
+      # instance used as the default for {Agent#initialize}; constructing
+      # additional instances is harmless but pointless.
+      class Empty < Catalog
+        # @return [Array<Skill>] always empty
+        def list
+          [].freeze
+        end
+
+        # @return [nil]
+        def get(_name)
+          nil
+        end
+      end
+
+      # Shared singleton for the no-skills case. Frozen.
+      EMPTY = Empty.new.freeze
+
+      # On-disk catalog: eager-scans the given +roots+ at construction
+      # and freezes itself. Use {.discover} to build one against
+      # pikuri's conventional locations; pass +roots:+ directly in
+      # tests so collision and ordering behavior can be exercised
+      # without staging dirs under +~/+.
+      #
+      # == Precedence
+      #
+      # +roots+ is processed left to right. The *first* skill seen for
+      # a given name wins; later occurrences are dropped with a warning
+      # logged through +Pikuri.logger_for('Skills')+. Callers that want
+      # "project beats global" pass project roots first.
+      #
+      # == Validation
+      #
+      # The Agent Skills standard is enforced leniently. A missing
+      # +description+ is the only hard failure (the skill is skipped);
+      # name/dir mismatch, oversized name/description, invalid name
+      # characters, malformed YAML — all log warnings and the skill
+      # still loads with whatever could be salvaged. Skills without
+      # a YAML frontmatter block at all are skipped silently (the file
+      # is presumably not meant as a skill).
+      class Bundled < Catalog
+        # Build a catalog from pikuri's conventional discovery roots:
+        # project skills (walked from +cwd+ up to the git root or
+        # filesystem root) take precedence over global skills (under
+        # the user's home directory). Within each tier, the order in
+        # {SKILL_DIR_NAMES} applies (+.pikuri+ ➜ +.claude+ ➜ +.agents+).
+        #
+        # Non-existent directories are skipped silently; the loaded
+        # set is whatever existed at construction time.
+        #
+        # @param cwd [String, Pathname] working directory whose
+        #   ancestor chain is searched for project skill roots.
+        # @return [Bundled]
+        def self.discover(cwd: Dir.pwd)
+          new(roots: discover_project_roots(cwd: cwd) + discover_global_roots)
+        end
+
+        # Project roots walked from +cwd+ upwards, stopping at the
+        # nearest ancestor containing +.git+ (inclusive) or at the
+        # filesystem root. The deepest directory's roots appear first,
+        # so closer-to-CWD skills win on name collisions.
+        #
+        # @param cwd [String, Pathname]
+        # @return [Array<String>] absolute paths to existing dirs
+        def self.discover_project_roots(cwd:)
+          results = []
+          current = File.expand_path(cwd.to_s)
+          loop do
+            SKILL_DIR_NAMES.each do |sub|
+              candidate = File.join(current, sub)
+              results << candidate if File.directory?(candidate)
+            end
+
+            # Stop *after* processing the git root — git roots are
+            # natural project boundaries; ancestors above are someone
+            # else's project.
+            break if File.directory?(File.join(current, '.git'))
+
+            parent = File.dirname(current)
+            break if parent == current # filesystem root
+
+            current = parent
+          end
+          results
+        end
+
+        # Global roots under the user's home directory.
+        #
+        # @return [Array<String>] absolute paths to existing dirs
+        def self.discover_global_roots
+          home = Dir.home
+          SKILL_DIR_NAMES.map { |sub| File.join(home, sub) }
+                         .select { |dir| File.directory?(dir) }
+        end
+
+        # @param roots [Array<String, Pathname>] skill directories in
+        #   precedence order — first occurrence of a given skill name
+        #   wins.
+        # @return [Bundled]
+        def initialize(roots:)
+          super()
+          @skills = {}
+          roots.each { |root| scan_root(root.to_s) }
+          @skills.freeze
+          @list = @skills.values.freeze
+          freeze
+        end
+
+        # @return [Array<Skill>]
+        def list
+          @list
+        end
+
+        # @param name [String]
+        # @return [Skill, nil]
+        def get(name)
+          @skills[name]
+        end
+
+        private
+
+        def scan_root(root)
+          return unless File.directory?(root)
+
+          Dir.children(root).sort.each do |entry|
+            skill_dir = File.join(root, entry)
+            next unless File.directory?(skill_dir)
+
+            skill_md = File.join(skill_dir, 'SKILL.md')
+            next unless File.file?(skill_md)
+
+            skill = parse_skill(skill_md, parent_dir_name: entry)
+            next if skill.nil?
+
+            existing = @skills[skill.name]
+            if existing
+              LOGGER.warn(
+                "skill name '#{skill.name}' at #{skill_md} is shadowed by " \
+                "earlier entry at #{existing.location}"
+              )
+            else
+              @skills[skill.name] = skill
+            end
+          end
+        end
+
+        # Read +path+ and return a {Skill}, or +nil+ if the file is
+        # unusable (no frontmatter, no description, unreadable). Warnings
+        # for soft violations are logged but do not block loading.
+        def parse_skill(path, parent_dir_name:)
+          raw = File.read(path)
+          frontmatter, body = split_frontmatter(raw)
+
+          if frontmatter.nil?
+            LOGGER.warn("#{path}: no YAML frontmatter; skipped")
+            return nil
+          end
+
+          description = frontmatter['description'].to_s.strip
+          if description.empty?
+            LOGGER.warn("#{path}: missing required 'description'; skipped")
+            return nil
+          end
+
+          name = (frontmatter['name'] || parent_dir_name).to_s
+          validate_name(name, parent_dir_name: parent_dir_name, path: path)
+          validate_description(description, path: path)
+
+          Skill.new(
+            name: name,
+            description: description,
+            location: path,
+            body: body
+          )
+        rescue Errno::ENOENT, Errno::EACCES => e
+          LOGGER.warn("#{path}: #{e.class}: #{e.message}; skipped")
+          nil
+        end
+
+        # Split a SKILL.md into +[frontmatter_hash, body_string]+.
+        # Returns +[nil, raw]+ when there is no detectable frontmatter
+        # block. On YAML parse failure, logs a warning and returns
+        # +[{}, body]+ so the caller can still observe an empty
+        # frontmatter (which trips the "missing description" path
+        # below and discards the skill).
+        def split_frontmatter(content)
+          normalized = content.gsub(/\r\n?/, "\n")
+          return [nil, normalized] unless normalized.start_with?("---\n")
+
+          end_marker = normalized.index("\n---", 4)
+          return [nil, normalized] unless end_marker
+
+          yaml_str = normalized[4...end_marker]
+          body = normalized[(end_marker + 4)..].to_s
+          body = body.sub(/\A\n/, '')
+
+          parsed =
+            begin
+              YAML.safe_load(yaml_str) || {}
+            rescue Psych::SyntaxError => e
+              LOGGER.warn("frontmatter YAML parse error: #{e.message}")
+              {}
+            end
+          parsed = {} unless parsed.is_a?(Hash)
+
+          [parsed, body]
+        end
+
+        def validate_name(name, parent_dir_name:, path:)
+          if name != parent_dir_name
+            LOGGER.warn("#{path}: skill name '#{name}' does not match parent directory '#{parent_dir_name}'")
+          end
+          if name.length > MAX_NAME_LENGTH
+            LOGGER.warn("#{path}: skill name exceeds #{MAX_NAME_LENGTH} chars (#{name.length})")
+          end
+          unless /\A[a-z0-9-]+\z/.match?(name)
+            LOGGER.warn("#{path}: skill name '#{name}' contains invalid characters " \
+                        "(allowed: lowercase a-z, 0-9, hyphens)")
+          end
+          if name.start_with?('-') || name.end_with?('-')
+            LOGGER.warn("#{path}: skill name '#{name}' starts or ends with a hyphen")
+          end
+          return unless name.include?('--')
+
+          LOGGER.warn("#{path}: skill name '#{name}' contains consecutive hyphens")
+        end
+
+        def validate_description(description, path:)
+          return unless description.length > MAX_DESCRIPTION_LENGTH
+
+          LOGGER.warn(
+            "#{path}: description exceeds #{MAX_DESCRIPTION_LENGTH} chars (#{description.length})"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/pikuri/skill/extension.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Pikuri
+  # Namespace for the Skills feature. Built around the Agent Skills
+  # standard implemented in {Pikuri::Skill::Catalog} and
+  # {Pikuri::Skill::SkillTool}; this module hosts the *Extension* class
+  # ({Extension}) that wires the two into an {Pikuri::Agent}.
+  module Skill
+    # An {Pikuri::Agent::Extension} that auto-wires the Agent Skills
+    # standard onto an agent: appends the catalog's
+    # +<available_skills>+ block to the system prompt and registers
+    # the +skill+ tool so the LLM can load skill bodies on demand.
+    #
+    # == Usage
+    #
+    # Pass the extension via the +Agent.new+ block:
+    #
+    #   catalog = Pikuri::Skill::Catalog::Bundled.discover
+    #   Pikuri::Agent.new(transport: ..., system_prompt: ...) do |c|
+    #     c.add_extension Pikuri::Skill::Extension.new(catalog: catalog)
+    #   end
+    #
+    # The +configure+ hook is agent-agnostic — it appends a snippet
+    # and adds a tool, both of which sub-agents inherit verbatim
+    # through the existing snapshot mechanism. There is no per-agent
+    # state, so this extension does not implement +bind+ (inherits
+    # the empty default from {Pikuri::Agent::Extension}).
+    #
+    # == Empty catalog
+    #
+    # When the catalog is {Pikuri::Skill::Catalog#empty?}, the
+    # extension is a no-op — no snippet, no tool. Same semantics as
+    # the legacy +skill_catalog:+ kwarg on {Pikuri::Agent#initialize},
+    # which still routes through this extension as a transition layer
+    # until Step 5 of the gem-split refactor (see IDEAS.md).
+    class Extension
+      include Pikuri::Agent::Extension
+
+      # @param catalog [Pikuri::Skill::Catalog] the catalog of
+      #   skills the agent may load. Required.
+      def initialize(catalog:)
+        @catalog = catalog
+      end
+
+      # @return [Pikuri::Skill::Catalog]
+      attr_reader :catalog
+
+      # Append +<available_skills>+ to the system prompt and
+      # register the +skill+ tool. No-op when the catalog is empty.
+      #
+      # The catalog's +format_for_prompt+ historically returns a
+      # snippet with leading blank lines (designed for the old
+      # +system_prompt + format_for_prompt+ concatenation). The
+      # Configurator handles the separator between base and snippet
+      # itself ({Configurator#append_system_prompt} drains with a
+      # +\n\n+ join), so we +lstrip+ to avoid doubling up the blank
+      # lines.
+      #
+      # @param c [Pikuri::Agent::Configurator]
+      # @return [void]
+      def configure(c)
+        return if @catalog.empty?
+
+        if c.tools.any?(Pikuri::Skill::SkillTool)
+          raise 'Pikuri::Skill::SkillTool cannot be pre-registered (in tools: or via c.add_tool) ' \
+                'when adding Pikuri::Skill::Extension — the extension auto-registers it from the catalog.'
+        end
+
+        c.append_system_prompt(@catalog.format_for_prompt.lstrip)
+        c.add_tool(Pikuri::Skill::SkillTool.new(catalog: @catalog))
+        nil
+      end
+    end
+  end
+end

data/lib/pikuri/skill/skill_tool.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Pikuri
+  module Skill
+    # The +skill+ tool: instantiating
+    # +Pikuri::Skill::SkillTool.new(catalog:)+ produces a tool whose
+    # +execute+ closure looks the requested name up in the bound
+    # {Catalog} and returns the skill's body wrapped in a +<skill>+
+    # block with the absolute base directory, so the LLM can resolve
+    # relative sidecar paths against it via the regular +read+ tool.
+    #
+    # The catalog of available skills is *not* duplicated into this
+    # tool's description. It lives in the system prompt — see
+    # {Catalog#format_for_prompt} — because skills describe what the
+    # agent is, not just what one of its tools returns. Putting the
+    # catalog in the system prompt keeps it next to the agent's persona
+    # and matches what PI and Claude Code do (opencode is the outlier
+    # here). The tool description below is therefore *static* — it
+    # explains the load mechanism, not the inventory.
+    #
+    # This tool is not registered manually. {Extension#configure}
+    # auto-registers it whenever the catalog is non-empty, and skips
+    # it otherwise; sub-agents inherit it through the parent's tool
+    # snapshot. The bound catalog rides along in the +execute+
+    # closure, so any sub-agent invoking +skill+ resolves names
+    # against the same catalog the parent saw.
+    class SkillTool < Pikuri::Tool
+      # Description shown to the LLM. Follows the opencode-shape (summary
+      # + +Usage:+ bullets) prescribed by the project's tool-description
+      # convention. The list of which skills exist is not here — see
+      # the class header.
+      #
+      # @return [String]
+      DESCRIPTION = <<~DESC
+        Load a specialized skill that provides domain-specific instructions and resources for a particular task.
+
+        Usage:
+        - The catalog of available skills is listed in your system prompt under `<available_skills>`.
+        - Invoke this tool with a skill's `name` to inject its full instructions into the conversation.
+        - The loaded skill may reference helper scripts and files in its base directory — use the `read` tool to load those when the skill's instructions tell you to.
+        - On `Error: skill '...' not found`, do NOT retry with a guessed name. Pick a name that actually appears in `<available_skills>`, or report to the user that no matching skill is installed.
+      DESC
+
+      # @param catalog [Catalog] the catalog to resolve names against.
+      #   Captured by closure so the tool retains access to the same
+      #   instance even when copied into a sub-agent's tool snapshot.
+      # @return [SkillTool]
+      def initialize(catalog:)
+        super(
+          name: 'skill',
+          description: DESCRIPTION,
+          parameters: Pikuri::Tool::Parameters.build { |p|
+            p.required_string :name,
+                              'Name of the skill to load, e.g. "pdf-extraction". ' \
+                              'Must match a name listed under `<available_skills>` ' \
+                              'in the system prompt.'
+          },
+          execute: lambda { |name:|
+            loaded = catalog.get(name)
+            if loaded.nil?
+              available = catalog.list.map(&:name).sort
+              list = available.empty? ? 'none' : available.join(', ')
+              next "Error: skill '#{name}' not found. Available skills: #{list}."
+            end
+
+            base_dir = File.dirname(loaded.location)
+            <<~OUT
+              <skill name="#{loaded.name}" location="#{loaded.location}">
+              Sidecar paths in this skill (e.g. scripts/, references/) are relative to #{base_dir}.
+
+              #{loaded.body}
+              </skill>
+            OUT
+          }
+        )
+      end
+    end
+  end
+end

data/lib/pikuri-skills.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'pikuri-core'
+
+# Entry file for the pikuri-skills gem. Sets up a dedicated Zeitwerk
+# loader rooted at this gem's +lib/+, contributing to the shared
+# +Pikuri::+ namespace alongside pikuri-core. After +require
+# 'pikuri-skills'+, +Pikuri::Skill::Catalog+, +Pikuri::Skill::SkillTool+
+# and +Pikuri::Skill::Extension+ are all defined.
+#
+# The loader is per-gem (not shared with pikuri-core's loader) so each
+# gem owns its own +lib/+ tree and the cooperation between gems is via
+# the Pikuri namespace alone. See pikuri-core/lib/pikuri-core.rb for
+# the core loader.
+module Pikuri
+  module Skill
+    LOADER = Zeitwerk::Loader.new
+    LOADER.tag = 'pikuri-skills'
+    LOADER.push_dir(File.expand_path('.', __dir__))
+    LOADER.ignore(__FILE__)
+    LOADER.setup
+    LOADER.eager_load
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: pikuri-skills
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Martin Vysny
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-05-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pikuri-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+description: |
+  pikuri-skills implements the Agent Skills standard
+  (agentskills.io) for pikuri-core agents: a +Pikuri::Skill::Catalog+
+  that discovers skill folders under .pikuri/skills, .claude/skills,
+  and .agents/skills; a +Pikuri::Skill::SkillTool+ that loads a
+  skill's body on demand; and a +Pikuri::Skill::Extension+ that wires
+  both into a +Pikuri::Agent+ via +c.add_extension(...)+ in the
+  +Agent.new+ block.
+email:
+- martin@vysny.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/pikuri-skills.rb
+- lib/pikuri/skill/catalog.rb
+- lib/pikuri/skill/extension.rb
+- lib/pikuri/skill/skill_tool.rb
+homepage: https://codeberg.org/mvysny/pikuri
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://codeberg.org/mvysny/pikuri/src/branch/master
+  changelog_uri: https://codeberg.org/mvysny/pikuri/src/branch/master/CHANGELOG.md
+  bug_tracker_uri: https://codeberg.org/mvysny/pikuri/issues
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Agent Skills standard support for pikuri.
+test_files: []