gem-skill 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e549225e7af0a6d96b302304225a274d5f5aa6074e8546c64034b3aba056d675
-  data.tar.gz: f2791cd10d4e1483763a890bb864cb5169ab6fc1c5239ae697e104d70ec1d898
+  metadata.gz: e537a3925c494c903dc9dd105d6a975d55d5fe55f963847cca3c363ce26120d6
+  data.tar.gz: 7f4fd4cff99d062ab50bf73b733aeddca903f23ffb657ccc7cc7616dcd7e2fe6
 SHA512:
-  metadata.gz: 7a75fec793180d52a07e7eb42c84d79eca1ba720aec44c33ec13f6783678ec96770f0bbe0ce4789ecdfdafc6c7df882c392fcea9e48f55fb99d47877dff0b7b6
-  data.tar.gz: d605f135da72c0bcdf5cb5f85c42b1f40bc5d13f46330264fd420401faa43dc67503949592c3dd15cfba0b62115b8a14a97d1850072a32309ad10a1833cbfb9c
+  metadata.gz: 2d74ee4cdbf3b827984574580985426ec708e7dfd901f2ddb99f03268afdcc96a2ab9f8962781549c053e587f1ecbd4f0d5cab06189adb24603af475083ab54e
+  data.tar.gz: e012f26a513a5516d606c6664c1ccd470ed910bd57190850e96daf1bc88e686e00dfbfc2b6f9bd8a467bdde6d5ca938b3084697ca27d2a956043b05e9d8dac37

data/.envrc

@@ -0,0 +1 @@
+export RR=`pwd`

data/README.md

@@ -31,7 +31,7 @@ Each project's `.claude/skills/` holds symlinks that point into this cache:
 
 ```
 your-app/.claude/skills/
-└── chunker-ruby.md  →  ~/.gem/skills/chunker-ruby/1.2.3/SKILL.md
+└── chunker-ruby/  →  ~/.gem/skills/chunker-ruby/1.2.3/
 ```
 
 Two projects that pin different versions of the same gem each get the right
@@ -41,17 +41,14 @@ skill; the underlying content is generated once and shared.
 
 ```bash
 gem install gem-skill
+gem skill setup
 ```
 
-This gives you the `gem skill` subcommand.
+`gem install` gives you the `gem skill` subcommand.
+`gem skill setup` registers gem-skill as a Bundler plugin, enabling `bundle skill` in any project.
 
-For `bundle skill` support (project-aware, reads `Gemfile.lock`), also run:
-
-```bash
-bundle plugin install gem-skill
-```
-
-or add it to your `Gemfile`:
+You only need to run `gem skill setup` once per machine. Alternatively, you can
+add the plugin directly to a project's `Gemfile`:
 
 ```ruby
 plugin "gem-skill"
@@ -117,6 +114,16 @@ gem skill purge chunker-ruby --all
 
 If a gem isn't installed locally, `gem skill install` will install it first.
 
+### `gem skill setup`
+
+Run once after `gem install gem-skill` to enable `bundle skill` globally:
+
+```bash
+gem skill setup
+```
+
+This registers gem-skill as a Bundler plugin so `bundle skill` works in every project.
+
 ### `gem install --with-skill`
 
 Generate skills for gems as you install them:
@@ -146,9 +153,6 @@ bundle skill install --force
 bundle skill install --model claude-haiku-4-5
 ```
 
-The `install` and `refresh` commands stream LLM output as it is generated, so
-you see progress rather than a silent wait.
-
 ## What gets generated
 
 Each `SKILL.md` covers:

data/lib/gem/skill/cli/bundle_command.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
+require "async"
 require "fileutils"
 require "json"
+require "tty-spinner"
 require "gem/skill"
 
 module Gem::Skill
@@ -35,42 +37,33 @@ module Gem::Skill
         return
       end
 
-      force = opts[:force]
-      model = opts[:model] || Generator::DEFAULT_MODEL
+      force  = opts[:force]
+      model  = opts[:model] || Generator::DEFAULT_MODEL
       errors = []
 
-      puts "Installing skills for #{gems.size} gem(s) (model: #{model})..."
-      puts ""
-
-      gems.each do |gem_name, version|
-        if Cache.cached?(gem_name, version) && !force
-          print "  skip  #{gem_name} #{version}"
-        else
-          print "  gen   #{gem_name} #{version}  "
-          $stdout.flush
-          Generator.new(gem_name, version, model: model).generate(force: force) do |chunk|
-            print chunk
-            $stdout.flush
+      multi = TTY::Spinner::Multi.new(
+        "[:spinner] Installing skills (#{model})",
+        format: :dots,
+        output: $stderr
+      )
+
+      Async do
+        barrier = Async::Barrier.new
+        gems.each do |gem_name, version|
+          sp = multi.register("  [:spinner] :title")
+          sp.update(title: "#{gem_name} #{version}")
+          barrier.async do
+            err = install_one(gem_name, version, sp, force: force, model: model)
+            errors << "#{gem_name} #{version}: #{err}" if err
           end
         end
-
-        Linker.link(gem_name, version)
-        puts "  ✓"
-      rescue Gem::Skill::Error => e
-        puts "  ✗ #{e.message}"
-        errors << "#{gem_name} #{version}: #{e.message}"
+        barrier.wait
+      ensure
+        barrier.stop
       end
 
       Linker.prune_dead_links
-
-      puts ""
-      puts "Done. #{gems.size - errors.size}/#{gems.size} skill(s) linked into .claude/skills/"
-
-      if errors.any?
-        puts ""
-        puts "Errors:"
-        errors.each { |e| puts "  #{e}" }
-      end
+      report_errors(errors)
     end
 
     def self.refresh(opts = {})
@@ -80,40 +73,35 @@ module Gem::Skill
       model  = opts[:model] || Generator::DEFAULT_MODEL
       errors = []
 
-      puts "Refreshing skills (model: #{model})..."
-      puts ""
-
-      gems.each do |gem_name, version|
-        if !force && linked[gem_name] == version
-          puts "  ok    #{gem_name} #{version}"
-          next
-        end
-
-        action = linked.key?(gem_name) ? "update" : "new"
-        print "  #{action.ljust(6)}#{gem_name} #{version}  "
-        $stdout.flush
-
-        Generator.new(gem_name, version, model: model).generate(force: force) do |chunk|
-          print chunk
-          $stdout.flush
+      multi = TTY::Spinner::Multi.new(
+        "[:spinner] Refreshing skills (#{model})",
+        format: :dots,
+        output: $stderr
+      )
+
+      Async do
+        barrier = Async::Barrier.new
+        gems.each do |gem_name, version|
+          sp = multi.register("  [:spinner] :title")
+          sp.update(title: "#{gem_name} #{version}")
+          barrier.async do
+            err = if !force && linked[gem_name] == version
+              sp.auto_spin
+              sp.success("up to date")
+              nil
+            else
+              install_one(gem_name, version, sp, force: force, model: model)
+            end
+            errors << "#{gem_name} #{version}: #{err}" if err
+          end
         end
-
-        Linker.link(gem_name, version)
-        puts "  ✓"
-      rescue Gem::Skill::Error => e
-        puts "  ✗ #{e.message}"
-        errors << "#{gem_name} #{version}: #{e.message}"
+        barrier.wait
+      ensure
+        barrier.stop
       end
 
       Linker.prune_dead_links
-
-      puts ""
-      puts "Refreshed."
-      if errors.any?
-        puts ""
-        puts "Errors:"
-        errors.each { |e| puts "  #{e}" }
-      end
+      report_errors(errors)
     end
 
     def self.list
@@ -124,8 +112,8 @@ module Gem::Skill
         return
       end
 
-      ok      = entries.count { |e| e[:valid] }
-      broken  = entries.size - ok
+      ok     = entries.count { |e| e[:valid] }
+      broken = entries.size - ok
 
       puts "Skills linked in .claude/skills/  (#{ok} ok#{broken > 0 ? ", #{broken} broken" : ""}):"
       puts ""
@@ -137,6 +125,20 @@ module Gem::Skill
 
     # --- private ---
 
+    def self.install_one(gem_name, version, spinner, force:, model:)
+      spinner.auto_spin
+      Runner.install_skill(gem_name, version, spinner, force: force, model: model)
+    end
+    private_class_method :install_one
+
+    def self.report_errors(errors)
+      return if errors.empty?
+      warn ""
+      warn "Errors (#{errors.size}):"
+      errors.each { |e| warn "  #{e}" }
+    end
+    private_class_method :report_errors
+
     def self.parse_options(args)
       opts      = {}
       remaining = []

data/lib/gem/skill/cli/gem_command.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "rubygems/command"
+require "async"
 require "fileutils"
 require "json"
 require "tty-spinner"
@@ -20,14 +21,15 @@ class Gem::Commands::SkillCommand < Gem::Command
   end
 
   def arguments
-    "SUBCOMMAND  one of: install, list, purge"
+    "SUBCOMMAND  one of: install, list, purge, setup"
   end
 
   def usage
     "#{program_name} install GEM_NAME [GEM_NAME ...]\n" \
     "       #{program_name} list\n" \
     "       #{program_name} purge GEM_NAME VERSION\n" \
-    "       #{program_name} purge GEM_NAME --all"
+    "       #{program_name} purge GEM_NAME --all\n" \
+    "       #{program_name} setup"
   end
 
   def description
@@ -35,9 +37,9 @@ class Gem::Commands::SkillCommand < Gem::Command
       install   Generate and cache a SKILL.md for a gem.
       list      Show all skills in the global cache (~/.gem/skills).
       purge     Remove a specific cached version.
+      setup     Register gem-skill as a Bundler plugin (run once after install).
 
-      Use 'bundle skill install' (after: bundle plugin install gem-skill)
-      to generate and link skills for an entire project from Gemfile.lock.
+      Use 'bundle skill install' in any project after running 'gem skill setup'.
     DESC
   end
 
@@ -48,6 +50,7 @@ class Gem::Commands::SkillCommand < Gem::Command
     when "install" then cmd_install
     when "list"    then cmd_list
     when "purge"   then cmd_purge
+    when "setup"   then cmd_setup
     when nil
       say usage
     else
@@ -76,36 +79,33 @@ class Gem::Commands::SkillCommand < Gem::Command
       output: $stderr
     )
 
-    threads = gem_names.map do |gem_name|
-      spinner = multi.register("  [:spinner] :title")
-      spinner.update(title: gem_name)
-      Thread.new(gem_name, spinner) { |name, sp| install_one(name, spinner: sp, force: force, model: model) }
+    Async do
+      barrier = Async::Barrier.new
+      gem_names.each do |gem_name|
+        spinner = multi.register("  [:spinner] :title")
+        spinner.update(title: gem_name)
+        barrier.async { install_one(gem_name, spinner: spinner, force: force, model: model) }
+      end
+      barrier.wait
+    ensure
+      barrier.stop
     end
-    threads.each(&:join)
 
     say "Tip: run 'bundle plugin install gem-skill' to enable 'bundle skill'."
   end
 
   def install_one(gem_name, spinner:, force:, model:)
     spinner.auto_spin
-
     version = resolve_installed_version(gem_name)
     if version.nil?
       spinner.update(title: "#{gem_name} (installing...)")
       version = install_gem(gem_name)
     end
-
-    if Gem::Skill::Cache.cached?(gem_name, version) && !force
-      spinner.update(title: "#{gem_name} #{version}")
-      spinner.success("already cached")
-      return
-    end
-
     spinner.update(title: "#{gem_name} #{version}")
-    Gem::Skill::Generator.new(gem_name, version, model: model).generate(force: force)
-    spinner.success("done")
-  rescue => e
-    spinner.error("#{gem_name} failed")
+    err = Gem::Skill::Runner.install_skill(gem_name, version, spinner, force: force, model: model)
+    alert_error "#{gem_name}: #{err}" if err
+  rescue Gem::Skill::Error => e
+    spinner.error("failed")
     alert_error "#{gem_name}: #{e.message}"
   end
 
@@ -127,6 +127,15 @@ class Gem::Commands::SkillCommand < Gem::Command
     say "#{gems.size} gem(s), #{gems.sum { |n| Gem::Skill::Cache.versions(n).size }} version(s) total."
   end
 
+  def cmd_setup
+    say "Registering gem-skill as a Bundler plugin..."
+    if system("bundle", "plugin", "install", "gem-skill")
+      say "Done. Use 'bundle skill install' in any project."
+    else
+      alert_error "Failed. Try running manually: bundle plugin install gem-skill"
+    end
+  end
+
   def cmd_purge
     gem_name = options[:args].shift
     unless gem_name

data/lib/gem/skill/generator.rb

@@ -21,7 +21,9 @@ module Gem::Skill
       Output raw Markdown directly. Do NOT wrap the output in a code fence or any
       other container — the file is Markdown, so no ```markdown wrapper.
 
-      Begin immediately with the first section heading. Use exactly these sections:
+      Begin with a top-level heading identifying the gem and version, then use exactly these sections:
+
+      # %<gem_name>s v%<version>s
 
       ## Overview
       One paragraph: what the gem does and when to reach for it.

data/lib/gem/skill/linker.rb

@@ -4,26 +4,28 @@ require "fileutils"
 
 module Gem::Skill
   # Manages .claude/skills/ symlinks in a project, pointing to ~/.gem/skills cache.
+  # Each symlink is a directory link: <gem_name> -> ~/.gem/skills/<gem>/<version>/
+  # Claude Code discovers skills by reading SKILL.md inside each linked directory.
   module Linker
     def self.skills_dir(project_root = Dir.pwd)
       File.join(project_root, ".claude", "skills")
     end
 
     def self.link(gem_name, version, project_root = Dir.pwd)
-      target = Cache.skill_path(gem_name, version)
+      target_dir = File.dirname(Cache.skill_path(gem_name, version))
       raise Error, "No cached skill for #{gem_name} #{version}. Run: gem skill install #{gem_name}" \
-        unless File.exist?(target)
+        unless File.exist?(Cache.skill_path(gem_name, version))
 
       dir = skills_dir(project_root)
       FileUtils.mkdir_p(dir)
 
-      link_path = File.join(dir, "#{gem_name}.md")
+      link_path = File.join(dir, gem_name)
       File.unlink(link_path) if File.symlink?(link_path)
-      File.symlink(target, link_path)
+      File.symlink(target_dir, link_path)
     end
 
     def self.unlink(gem_name, project_root = Dir.pwd)
-      link_path = File.join(skills_dir(project_root), "#{gem_name}.md")
+      link_path = File.join(skills_dir(project_root), gem_name)
       File.unlink(link_path) if File.symlink?(link_path)
     end
 
@@ -31,13 +33,14 @@ module Gem::Skill
       dir = skills_dir(project_root)
       return [] unless Dir.exist?(dir)
 
-      Dir.glob(File.join(dir, "*.md")).filter_map do |path|
+      Dir.glob(File.join(dir, "*")).filter_map do |path|
         next unless File.symlink?(path)
 
-        gem_name = File.basename(path, ".md")
-        target   = File.readlink(path)
-        version  = target.match(%r{/([^/]+)/SKILL\.md$})&.captures&.first
-        { gem_name: gem_name, version: version, target: target, valid: File.exist?(target) }
+        gem_name   = File.basename(path)
+        target_dir = File.readlink(path)
+        version    = target_dir.match(%r{/([^/]+)$})&.captures&.first
+        skill_file = File.join(target_dir, "SKILL.md")
+        { gem_name: gem_name, version: version, target: target_dir, valid: File.exist?(skill_file) }
       end
     end
 

data/lib/gem/skill/lockfile.rb

@@ -11,9 +11,9 @@ module Gem::Skill
     end
 
     def self.parse(content)
-      specs   = parse_specs(content)
-      direct  = parse_direct_names(content)
-      direct.each_with_object({}) do |name, hash|
+      specs  = parse_specs(content)
+      direct = parse_direct_names(content) + parse_path_dep_names(content)
+      direct.uniq.each_with_object({}) do |name, hash|
         hash[name] = specs[name] if specs.key?(name)
       end
     end
@@ -36,6 +36,33 @@ module Gem::Skill
       specs
     end
 
+    def self.parse_path_dep_names(content)
+      in_path  = false
+      in_specs = false
+      in_gem   = false
+      names    = []
+
+      content.each_line do |line|
+        if line.strip == "PATH"
+          in_path = true
+          in_specs = false
+          in_gem   = false
+        elsif in_path && line.strip == "specs:"
+          in_specs = true
+        elsif in_path && in_specs && line =~ /\A {4}\S/
+          in_gem = true
+        elsif in_path && in_specs && in_gem && line =~ /\A {6}(\S+)/
+          names << Regexp.last_match(1)
+        elsif in_path && !line.start_with?(" ") && !line.strip.empty?
+          in_path  = false
+          in_specs = false
+          in_gem   = false
+        end
+      end
+
+      names
+    end
+
     def self.parse_direct_names(content)
       in_deps = false
       names   = []

data/lib/gem/skill/runner.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Gem::Skill
+  # Core install logic shared by gem_command and bundle_command.
+  # Callers are responsible for spinner.auto_spin and title setup before calling.
+  module Runner
+    # Generate + cache + link one skill.
+    # Returns nil on success, error message string on failure.
+    def self.install_skill(gem_name, version, spinner, force:, model:)
+      if Cache.cached?(gem_name, version) && !force
+        Linker.link(gem_name, version)
+        spinner.success("already cached")
+        return nil
+      end
+      Generator.new(gem_name, version, model: model).generate(force: force)
+      Linker.link(gem_name, version)
+      spinner.success("done")
+      nil
+    rescue => e
+      spinner.error("failed")
+      e.message
+    end
+  end
+end

data/lib/gem/skill/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Gem::Skill
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/gem/skill.rb

@@ -6,6 +6,7 @@ require_relative "skill/fetcher"
 require_relative "skill/generator"
 require_relative "skill/linker"
 require_relative "skill/lockfile"
+require_relative "skill/runner"
 
 module Gem::Skill
   class Error < StandardError; end

data/scripts/e2e_test

@@ -1,16 +1,20 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-# End-to-end test: fetch docs for a gem and generate a SKILL.md
-# Usage: bundle exec ruby bin/e2e_test [GEM_NAME [VERSION]]
+# End-to-end test: full pipeline for one gem — fetch, generate, cache, link.
+# Usage: bundle exec ruby scripts/e2e_test [GEM_NAME [VERSION [MODEL]]]
 
 $LOAD_PATH.unshift File.expand_path("../lib", __dir__)
 require "gem/skill"
-require "ruby_llm"
+require "gem/skill/runner"
+require "gem/skill/linker"
+require "async"
+require "tty-spinner"
+require "tmpdir"
 
 GEM_NAME = ARGV[0] || "zeitwerk"
 VERSION  = ARGV[1] || Gem::Specification.find_by_name(GEM_NAME)&.version&.to_s
-MODEL    = ARGV[2] || "gpt-4o-mini"
+MODEL    = ARGV[2] || Gem::Skill::Generator::DEFAULT_MODEL
 
 abort "Gem '#{GEM_NAME}' not installed. Run: gem install #{GEM_NAME}" unless VERSION
 
@@ -29,43 +33,73 @@ puts ""
 puts "[ FETCH ]"
 fetcher = Gem::Skill::Fetcher.new(GEM_NAME, VERSION)
 sources = fetcher.fetch_all
+abort "No sources found — nothing to generate from." if sources.empty?
 
-if sources.empty?
-  abort "No sources found — nothing to generate from."
-end
-
-sources.each do |name, content|
-  puts "  %-12s %d chars" % [name, content.length]
-end
+sources.each { |name, content| puts "  %-12s %d chars" % [name, content.length] }
 puts ""
 
-# --- Phase 2: Generate ---
-
-puts "[ GENERATE ]  streaming output below"
-puts "-" * 60
-
-skill_content = ""
-generator = Gem::Skill::Generator.new(GEM_NAME, VERSION, model: MODEL)
-skill_content = generator.generate(force: true) do |chunk|
-  print chunk
-  $stdout.flush
+# --- Phase 2: Runner.install_skill via async fiber ---
+
+puts "[ RUNNER ]  (via Async fiber + TTY spinner)"
+multi = TTY::Spinner::Multi.new("[:spinner] Installing skill", format: :dots, output: $stderr)
+sp    = multi.register("  [:spinner] :title")
+sp.update(title: "#{GEM_NAME} #{VERSION}")
+
+err = nil
+Async do
+  barrier = Async::Barrier.new
+  barrier.async do
+    sp.auto_spin
+    err = Gem::Skill::Runner.install_skill(GEM_NAME, VERSION, sp, force: true, model: MODEL)
+  end
+  barrier.wait
+ensure
+  barrier.stop
 end
 
-puts ""
-puts "-" * 60
+if err
+  abort "\nRunner failed: #{err}"
+end
 puts ""
 
 # --- Phase 3: Verify cache ---
 
 puts "[ CACHE ]"
 cached_path = Gem::Skill::Cache.skill_path(GEM_NAME, VERSION)
-if File.exist?(cached_path)
-  puts "  Written: #{cached_path}"
-  puts "  Size:    #{File.size(cached_path)} bytes"
-else
-  puts "  ERROR: cache file not found at #{cached_path}"
-  exit 1
+abort "  ERROR: cache file not found at #{cached_path}" unless File.exist?(cached_path)
+
+metadata_path = Gem::Skill::Cache.metadata_path(GEM_NAME, VERSION)
+puts "  SKILL.md:  #{cached_path} (#{File.size(cached_path)} bytes)"
+puts "  metadata:  #{metadata_path} (#{File.exist?(metadata_path) ? "present" : "MISSING"})"
+puts ""
+
+# --- Phase 4: Linker ---
+
+puts "[ LINKER ]"
+project_dir = Dir.mktmpdir("gem-skill-e2e")
+begin
+  Gem::Skill::Linker.link(GEM_NAME, VERSION, project_dir)
+
+  link_path  = File.join(project_dir, ".claude", "skills", GEM_NAME)
+  skill_via_link = File.join(link_path, "SKILL.md")
+
+  abort "  ERROR: symlink not created at #{link_path}" unless File.symlink?(link_path)
+  abort "  ERROR: symlink does not resolve to a directory" unless File.directory?(link_path)
+  abort "  ERROR: SKILL.md not accessible through symlink" unless File.exist?(skill_via_link)
+
+  puts "  symlink:   #{link_path}"
+  puts "  -> target: #{File.readlink(link_path)}"
+  puts "  SKILL.md accessible through symlink: yes"
+
+  entries = Gem::Skill::Linker.linked_gems(project_dir)
+  entry   = entries.find { |e| e[:gem_name] == GEM_NAME }
+  abort "  ERROR: linked_gems did not return #{GEM_NAME}" unless entry
+  puts "  linked_gems reports: #{entry.inspect}"
+ensure
+  FileUtils.rm_rf(project_dir)
 end
 
 puts ""
-puts "Done."
+puts "=" * 60
+puts "All phases passed."
+puts "=" * 60

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gem-skill
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Dewayne VanHoozer
@@ -10,21 +10,21 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: ruby_llm
+  name: async
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: thor
+  name: ruby_llm
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -62,6 +62,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".envrc"
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
@@ -74,6 +75,7 @@ files:
 - lib/gem/skill/generator.rb
 - lib/gem/skill/linker.rb
 - lib/gem/skill/lockfile.rb
+- lib/gem/skill/runner.rb
 - lib/gem/skill/version.rb
 - lib/rubygems_plugin.rb
 - plugins.rb
@@ -86,6 +88,17 @@ metadata:
   homepage_uri: https://github.com/madbomber/gem-skill
   source_code_uri: https://github.com/madbomber/gem-skill
   changelog_uri: https://github.com/madbomber/gem-skill/blob/master/CHANGELOG.md
+post_install_message: |
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+    gem-skill installed!
+
+    'gem skill install GEM_NAME' is ready to use.
+
+    To enable 'bundle skill' in your projects, run:
+
+      gem skill setup
+
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 rdoc_options: []
 require_paths:
 - lib