skill 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d71981592f86798fc080114f847e07e7889bbe32b3cd7d6e41f1830e9c9be3f7
-  data.tar.gz: e7aa70524f1d82775670aa06c9bddb7073e337f5be30fa27b8f039f8b9b02dc1
+  metadata.gz: ee5cb9655ef0c0e762233b03de1732a2d623c3d2c73c3ed194ef4642abbb56da
+  data.tar.gz: e868591ccda4402de0f8ee1fd5d6dd69cffa35b46a6d37c3155e4efa4638987a
 SHA512:
-  metadata.gz: 8d880355668cece71955dc47f5cce34ac20dfa4155b8fdc66239ba7e5b4de3dc50c5b46ca05c9ceb608e5f14341c58484f7618485891ba4333229d1e6021d508
-  data.tar.gz: 0a9e6294de982fc8c93464b436b24d31e217f6d9fc3d85d74c89fa2edeab98088470819fc22c41ab1260de1edb4555b103def81ffdf2c2b695a6bd0c3a70ac53
+  metadata.gz: c201ca2ec016eadcfd7c169fef7697f08c2f23acec0af9c1c19e35c123864389c6b1068054e0404672684b689e361d86caf01e43d95fb52e1f686ce73c4e82bb
+  data.tar.gz: 7c8d2af1802808d86e6a81e30d137d715c1a4386d9d8ca5c606ce5ac1debb91fb815ed998d1bdf9e8ef89dd8f630e1941bfe7384e94c7a81d8d4de16d27ae93d

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 Each release's notes are in [`packaging/release-notes/`](packaging/release-notes) and on [GitHub Releases](https://github.com/crmne/skill/releases).
 
+## 0.2.0 (2026-10-17)
+
+`--agents` with the `all` and `coding` groups, `skill install` to restore a lockfile, and the global lockfile in `~/.config/skill`. See [the notes](packaging/release-notes/v0.2.0.md).
+
 ## 0.1.0 (2026-10-17)
 
 The first release: `add`, `list`, `update`, `remove`, `find`, and `agents`. See [the notes](packaging/release-notes/v0.1.0.md).

data/README.md

@@ -91,7 +91,7 @@ Private repositories work with a token in `GITHUB_TOKEN` or `GH_TOKEN`.
 
 `skill` looks at your project and installs into every folder it shows signs of using:
 
-| Target | `--agent` | Project folder | Global folder | Detected by |
+| Target | `--agents` | Project folder | Global folder | Detected by |
 | --- | --- | --- | --- | --- |
 | RubyLLM | `rubyllm` | `app/skills` | none | `ruby_llm` in the Gemfile or lockfile, or an `app/skills` folder |
 | Claude Code | `claude-code` | `.claude/skills` | `~/.claude/skills` | `.claude/` or `CLAUDE.md` |
@@ -103,14 +103,26 @@ Private repositories work with a token in `GITHUB_TOKEN` or `GH_TOKEN`.
 
 When it finds none, it uses `.agents/skills`, the folder many agents share. `skill agents` lists all 80 targets. Folders several agents share get one copy.
 
-Choose instead of detecting:
+Choose instead of detecting with `--agents` (`-a`), a comma-separated list of groups and agent names:
+
+| `--agents` | Installs into |
+| --- | --- |
+| `all` | Every folder detected, RubyLLM's `app/skills` included in a RubyLLM project. The default |
+| `coding` | Every coding agent's folder detected, never RubyLLM's `app/skills` |
+| `ruby_llm` | RubyLLM's `app/skills` only |
+| `claude-code,cursor` | These agents' folders. `skill agents` lists the names |
+| `*` | Every agent `skill agents` lists |
 
 ```sh
-skill add anthropics/skills@pdf --agent rubyllm
-skill add anthropics/skills@pdf --agent claude-code,cursor
+skill add anthropics/skills@pdf --agents coding       # your coding agents, not your app
+skill add anthropics/skills@pdf --agents ruby_llm     # your app, not your coding agents
+skill add anthropics/skills@pdf --agents claude-code,cursor
+skill add anthropics/skills@pdf --agents coding,ruby_llm
 skill add anthropics/skills@pdf --dir vendor/skills
 ```
 
+`coding` and `all` fall back to `.agents/skills` when they detect nothing. `--agent` still works, as another name for `--agents`.
+
 ### Project or global
 
 Inside a project, `skill` installs into the project. Outside one, it installs globally, into your home folder, for the agents you have installed:
@@ -122,7 +134,7 @@ skill add anthropics/skills@pdf
 
 ```
 ✓ Installed pdf → ~/.claude/skills/pdf (global)
-  Recorded in ~/.local/state/skill/skills.lock
+  Recorded in ~/.config/skill/skills.lock
 ```
 
 A project is the nearest folder from where you run `skill` up that holds a `skills.lock`, a `Gemfile`, a `gems.rb`, a `.git`, or a `package.json`, or else an agent's folder or instructions (`.claude`, `.agents`, `.cursor`, `AGENTS.md`, `CLAUDE.md`, and the like). Your home folder never counts, since agents keep their global folders there. `list`, `update`, and `remove` decide the same way.
@@ -163,7 +175,28 @@ chat = RubyLLM.chat.with_skills(:pdf)
 }
 ```
 
-Entries are sorted and carry no timestamps, so two branches adding different skills merge cleanly. The global lockfile lives in `~/.local/state/skill/skills.lock` (or `$XDG_STATE_HOME/skill`).
+Entries are sorted and carry no timestamps, so two branches adding different skills merge cleanly.
+
+The global lockfile lives in `~/.config/skill/skills.lock` (or `$XDG_CONFIG_HOME/skill`), so you can keep it with your dotfiles, like a Brewfile. skill 0.1 kept it in `~/.local/state/skill`; the first command that reads it moves it and says so.
+
+## Installing from the lockfile
+
+`install` installs what `skills.lock` records, the way `bundle install` restores a `Gemfile.lock`: each skill at its recorded commit, into its recorded folders, creating any that are missing.
+
+```sh
+git clone https://github.com/acme/app && cd app
+skill install           # the project's skills
+skill install --global  # yours, on a new computer, from ~/.config/skill/skills.lock
+```
+
+```
+✓ Installed pdf → app/skills/pdf, .claude/skills/pdf
+· xlsx already installed
+```
+
+A skill already in place with its recorded digest is left alone. Each copy it downloads must match that digest, or nothing is installed. A copy you edited is replaced only with `--force`. `install` never moves a skill to a newer commit: that is `update`'s job.
+
+With a source, `skill install owner/repo` works like `skill add`, as `npx skills install` does.
 
 ## Updating
 
@@ -198,7 +231,7 @@ To move to another ref, add the skill again with it: `skill add anthropics/skill
 skill list              # installed skills, and any that were edited or are missing
 skill list --json
 skill remove pdf        # from every folder it was installed into
-skill remove pdf --agent claude-code
+skill remove pdf --agents claude-code
 ```
 
 `list` also names skill folders `skill` did not install. `remove` deletes only what `skill` installed.
@@ -237,7 +270,7 @@ A skill's instructions steer a model and its scripts run with whatever your sand
 * **Installs are atomic.** Copies are built beside their folders and swapped in once all are ready. A failure leaves everything as it was.
 * **Skills stay where they belong.** `add`, `update`, and `remove` write only inside the project, or when global inside your home folder (and any agent folder you moved elsewhere with its environment variable). Folders are checked with `..` and symbolic links resolved, so a `skills.lock` entry, a `--dir`, or a linked folder that leads elsewhere is refused with an error naming it, and nothing changes.
 * **Your edits are yours.** A skill edited since it was installed, or a folder `skill` did not install, is replaced or removed only with `--force`.
-* **No downloads at run time.** `skill` reaches the network only in `add`, `update`, and `find`. What it installs is plain files in your project.
+* **No downloads at run time.** `skill` reaches the network only in `add`, `install`, `update`, and `find`. What it installs is plain files in your project.
 * **GitHub without its API.** Refs come from git's own HTTP endpoint and files from one archive of the exact commit, so there is no rate limit and no git needed. A token, when set, goes only to GitHub.
 
 ## Environment
@@ -245,8 +278,8 @@ A skill's instructions steer a model and its scripts run with whatever your sand
 | Variable | Use |
 | --- | --- |
 | `GITHUB_TOKEN`, `GH_TOKEN` | Read private repositories |
-| `XDG_CONFIG_HOME`, `CLAUDE_CONFIG_DIR`, `CODEX_HOME` | Where agents keep their global folders |
-| `XDG_STATE_HOME` | Where the global lockfile lives |
+| `CLAUDE_CONFIG_DIR`, `CODEX_HOME` | Where those agents keep their global folders |
+| `XDG_CONFIG_HOME` | Where the global lockfile lives, and where some agents keep their global folders |
 | `INSTALL_INTERNAL_SKILLS` | Include skills whose front matter sets `metadata.internal: true` in `--all` |
 | `SKILLS_API_URL` | Another server with the skills.sh search endpoint |
 | `SKILL_MAX_*` | The limits above |

data/lib/skill/cli.rb

@@ -6,7 +6,8 @@ module Skill
   # The +skill+ command line.
   class CLI
     COMMANDS = {
-      'add' => :Add, 'install' => :Add, 'a' => :Add, 'i' => :Add,
+      'add' => :Add, 'a' => :Add,
+      'install' => :Install, 'i' => :Install,
       'list' => :List, 'ls' => :List,
       'update' => :Update, 'upgrade' => :Update, 'up' => :Update,
       'remove' => :Remove, 'rm' => :Remove, 'uninstall' => :Remove,
@@ -19,6 +20,7 @@ module Skill
 
       Commands:
         add <source>       Install skills from GitHub or a local folder
+        install            Install what skills.lock records, at its commits
         list               List installed skills
         update [names]     Update installed skills, showing what changes first
         remove <names>     Remove installed skills

data/lib/skill/commands/command.rb

@@ -17,13 +17,13 @@ module Skill
       attr_reader :session, :options
 
       # Parses the arguments with the options +define+ adds, plus the scope
-      # options (+--global+, +--project+, +--agent+, +--dir+) unless +scope+
-      # is false.
+      # options (+--global+, +--project+, +--agents+, +--dir+) unless +scope+
+      # is false, or only +--global+ and +--project+ when it is +:place+.
       # Returns the arguments left.
       def parse(banner, scope: true, &define)
         @parser = OptionParser.new do |opts|
           opts.banner = "Usage: skill #{banner}"
-          scope_options(opts) if scope
+          scope_options(opts, targets: scope != :place) if scope
           define&.call(opts)
         end
         @parser.parse(@argv)
@@ -33,12 +33,16 @@ module Skill
         @parser.to_s
       end
 
-      def scope_options(opts)
+      def scope_options(opts, targets: true)
         opts.on('-g', '--global', 'Use the home folder, even inside a project') { options[:global] = true }
         opts.on('-p', '--project', 'Use the current folder as a project, even outside one') do
           options[:global] = false
         end
-        opts.on('-a', '--agent NAME', 'Target this agent (repeatable, comma-separated, * for all)') do |value|
+        return unless targets
+
+        opts.on('-a', '--agents NAMES', '--agent NAMES',
+                'Target these agents (comma-separated, repeatable): all (detected, the default),',
+                'coding (detected coding agents, not RubyLLM), or names from `skill agents`') do |value|
           options[:agents].concat(split(value))
         end
         opts.on('-d', '--dir PATH', 'Target this folder (repeatable)') do |value|

data/lib/skill/commands/install.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Skill
+  module Commands
+    # skill install: installs what the lockfile records, each skill at its
+    # recorded commit, into its recorded folders, the way +bundle install+
+    # restores a Gemfile.lock. Skills already in place with the recorded
+    # digest are left alone, and each copy fetched is checked against that
+    # digest before it is written. Given a source, works as +skill add+.
+    class Install < Command
+      def run
+        return Add.new(session, @argv).run if @argv.any? { |argument| !argument.start_with?('-') }
+
+        names = parse('install [options]', scope: :place) do |opts|
+          opts.on('-f', '--force', 'Replace skills that were edited since they were installed') do
+            options[:force] = true
+          end
+        end
+        raise UsageError, "skill install takes no names.\n\n#{usage}" unless names.empty?
+
+        install
+      end
+
+      private
+
+      def install
+        lock = workspace.lock
+        return say("No skills recorded in #{workspace.display(lock.path)}.") if lock.names.empty?
+
+        missing = lock.names.to_h { |name| [name, missing_folders(name)] }.reject { |_name, folders| folders.empty? }
+        (lock.names - missing.keys).each do |name|
+          say "#{style.dim('·')} #{style.bold(name)} #{style.dim('already installed')}"
+        end
+        copies = missing.group_by { |name, _folders| lock[name].values_at('source', 'commit') }.values
+        restore(copies.flat_map { |group| fetch(group) })
+      end
+
+      def restore(copies)
+        return 0 if copies.empty?
+
+        Installer.new.install(copies)
+        copies.each { |copy| say done("Installed #{style.bold(copy.name)} → #{copy.labels.join(', ')}") }
+        0
+      end
+
+      # Returns the recorded folders of +name+ that do not hold it as
+      # recorded, after refusing any that hold an edited copy.
+      def missing_folders(name)
+        entry = workspace.lock[name]
+        workspace.folders(entry).reject do |folder|
+          path = Installer.destination(folder, name)
+          next true if workspace.unchanged?(path, entry)
+
+          workspace.ensure_replaceable(name, folder, options[:force])
+          false
+        end
+      end
+
+      # Returns the copies for +group+, pairs of a skill name and its
+      # folders, which share a source and a commit.
+      def fetch(group)
+        entry = workspace.lock[group.first.first]
+        checkout = session.fetcher.checkout(source(entry), resolution: resolution(entry))
+        group.map { |name, folders| copy(checkout, name, folders) }
+      end
+
+      def source(entry)
+        workspace.source_of(entry)
+      end
+
+      def resolution(entry)
+        commit = entry['commit']
+        return if commit.nil? || entry['ref_type'] == 'local'
+
+        unless commit.match?(/\A\h{40}\z/)
+          raise Error, "#{workspace.display(workspace.lock.path)} records an invalid commit for #{entry['source']}"
+        end
+
+        GitHub::Resolution.new(type: entry['ref_type'] == 'commit' ? :commit : entry['ref_type'].to_sym,
+                               name: entry['ref'], commit: commit.downcase, branch: entry['ref'])
+      end
+
+      def copy(checkout, name, folders)
+        entry = workspace.lock[name]
+        path = File.join(checkout.root, entry['path'].to_s)
+        raise NotFoundError, "#{name}: #{entry['path']} is gone from #{entry['source']}" unless File.directory?(path)
+        if checkout.link_inside?(entry['path'])
+          raise UnsafeError, "#{entry['path']} holds a symbolic link; skills may not hold links"
+        end
+
+        executable = entry['executable'] ? true : false
+        tree = Tree.read(path, limits: session.limits)
+        verify(name, entry, tree.digest(executable: executable))
+        Installer::Copy.new(name: name, tree: tree, targets: folders, executable: executable, entry: entry,
+                            labels: folders.map { |folder| workspace.display(File.join(folder, name)) })
+      end
+
+      def verify(name, entry, digest)
+        return if digest == entry['digest']
+
+        if entry['ref_type'] == 'local'
+          raise ConflictError, "#{name}: #{entry['source']} changed since it was recorded. " \
+                               'Run `skill update` to install what it holds now'
+        end
+        raise UnsafeError, "#{name}: #{entry['source']} at #{entry['commit'].to_s[0, 12]} does not match " \
+                           "the digest #{workspace.display(workspace.lock.path)} records"
+      end
+    end
+  end
+end

data/lib/skill/commands/remove.rb

@@ -3,7 +3,7 @@
 module Skill
   module Commands
     # skill remove <names>: deletes skills this command installed, from
-    # every folder it recorded, or only those +--agent+ and +--dir+ name.
+    # every folder it recorded, or only those +--agents+ and +--dir+ name.
     class Remove < Command
       def run
         names = parse('remove <names> [options]') do |opts|

data/lib/skill/commands.rb

@@ -7,6 +7,7 @@ module Skill
     autoload :Agents, 'skill/commands/agents'
     autoload :Command, 'skill/commands/command'
     autoload :Find, 'skill/commands/find'
+    autoload :Install, 'skill/commands/install'
     autoload :List, 'skill/commands/list'
     autoload :Remove, 'skill/commands/remove'
     autoload :Selection, 'skill/commands/selection'

data/lib/skill/lockfile.rb

@@ -8,7 +8,8 @@ module Skill
   # fetch it again and +remove+ knows what it owns. Entries are sorted by
   # name and carry no timestamps, so two branches adding different skills
   # merge cleanly. A project's lockfile sits at its root, to be committed;
-  # the global one in +$XDG_STATE_HOME/skill+ (+~/.local/state/skill+).
+  # the global one in +$XDG_CONFIG_HOME/skill+ (+~/.config/skill+), beside
+  # other settings people keep with their dotfiles.
   #
   #   {
   #     "version": 1,
@@ -35,10 +36,36 @@ module Skill
 
     # Returns the global lockfile's path.
     def self.global_path(env:, home:)
-      state = env['XDG_STATE_HOME'].to_s.strip
-      File.join(state.empty? ? File.join(home, '.local/state') : state, 'skill', NAME)
+      File.join(xdg(env, 'XDG_CONFIG_HOME', File.join(home, '.config')), 'skill', NAME)
     end
 
+    # Returns where skill 0.1 kept the global lockfile.
+    def self.legacy_global_path(env:, home:)
+      File.join(xdg(env, 'XDG_STATE_HOME', File.join(home, '.local/state')), 'skill', NAME)
+    end
+
+    # Moves the global lockfile from where skill 0.1 kept it, when only that
+    # one exists. Returns the old path when it moved it, else +nil+.
+    def self.migrate_global(env:, home:)
+      old = legacy_global_path(env: env, home: home)
+      current = global_path(env: env, home: home)
+      return unless File.file?(old) && !File.exist?(current)
+
+      FileUtils.mkdir_p(File.dirname(current))
+      File.rename(old, current)
+      old
+    rescue SystemCallError
+      FileUtils.cp(old, current)
+      FileUtils.rm_f(old)
+      old
+    end
+
+    def self.xdg(env, variable, default)
+      value = env[variable].to_s.strip
+      value.empty? ? default : value
+    end
+    private_class_method :xdg
+
     def initialize(path)
       @path = path
       @skills = File.exist?(path) ? parse(File.read(path, encoding: 'UTF-8')) : {}

data/lib/skill/session.rb

@@ -53,7 +53,11 @@ module Skill
     # Returns the Workspace for the project, or the home folder with
     # +global+, or with +global+ +nil+ whichever +cwd+ is in.
     def workspace(global: nil)
-      @workspace ||= Workspace.open(cwd: cwd, home: home, env: env, global: global, limits: limits)
+      @workspace ||= Workspace.open(cwd: cwd, home: home, env: env, global: global, limits: limits).tap do |space|
+        if space.moved_lock
+          warn("Moved the global lockfile from #{space.display(space.moved_lock)} to #{space.display(space.lock.path)}")
+        end
+      end
     end
 
     def limits

data/lib/skill/targets.rb

@@ -2,8 +2,9 @@
 
 module Skill
   # Decides which folders a command installs to, lists, or updates: the
-  # folders of the agents named with +--agent+, the folders named with
-  # +--dir+, or else the ones the project or home folder shows signs of.
+  # folders of the agents and groups named with +--agents+, the folders
+  # named with +--dir+, or else the ones the project or home folder shows
+  # signs of.
   class Targets
     # One folder skills are installed into, and the agents that read it.
     Target = Struct.new(:path, :label, :agents, keyword_init: true)
@@ -30,6 +31,14 @@ module Skill
 
     SHARED_GLOBAL_DIRS = %w[~/.agents/skills {config}/agents/skills].freeze
     FALLBACK = 'universal'
+    RUBY_LLM = 'rubyllm'
+
+    # Names +--agents+ takes for several agents at once: +all+, every agent
+    # detected (RubyLLM's +app/skills+ included in a RubyLLM project), and
+    # +coding+, every coding agent detected, never RubyLLM. Both fall back to
+    # the shared +.agents/skills+ folder when they detect none. +*+ is every
+    # agent +skill agents+ lists.
+    GROUPS = %w[all coding *].freeze
 
     attr_reader :root, :home, :env
 
@@ -45,11 +54,12 @@ module Skill
       @global
     end
 
-    # Returns the Targets for +agents+ and +dirs+, or the detected ones when
-    # both are empty. Folders several agents share are returned once.
+    # Returns the Targets for +agents+ (names, aliases, or GROUPS) and
+    # +dirs+, or the detected ones (the +all+ group) when both are empty.
+    # Folders several agents share are returned once.
     def resolve(agents: [], dirs: [])
-      chosen = agents_named(agents)
-      list = chosen.empty? && dirs.empty? ? detected : chosen.filter_map { |agent| target_for(agent, strict: true) }
+      agents = ['all'] if agents.empty? && dirs.empty?
+      list = agents_named(agents).filter_map { |agent| target_for(agent, strict: true) }
       list += dirs.map { |dir| Target.new(path: File.expand_path(dir, base), label: dir, agents: []) }
       merge(list)
     end
@@ -60,9 +70,11 @@ module Skill
     end
 
     # Returns the agents the project or home folder shows signs of, or the
-    # shared +.agents/skills+ folder when it shows none.
-    def detected_agents
+    # shared +.agents/skills+ folder when it shows none. With +coding+,
+    # leaves RubyLLM out.
+    def detected_agents(coding: false)
       found = Agents.all.select { |agent| global? ? installed?(agent) : used_in_project?(agent) }
+      found.reject! { |agent| agent.key == RUBY_LLM } if coding
       found.empty? ? [Agents.fetch(FALLBACK)] : found
     end
 
@@ -103,13 +115,14 @@ module Skill
     end
 
     def agents_named(names)
-      return Agents.all.select { |agent| global? ? agent.global? : true } if names.include?('*')
-
-      names.map { |name| Agents.fetch(name) }.uniq
-    end
-
-    def detected
-      detected_agents.filter_map { |agent| target_for(agent) }
+      names.flat_map do |name|
+        case name.to_s.strip.downcase
+        when '*' then Agents.all.select { |agent| global? ? agent.global? : true }
+        when 'all' then detected_agents
+        when 'coding' then detected_agents(coding: true)
+        else [Agents.fetch(name)]
+        end
+      end.uniq
     end
 
     def target_for(agent, strict: false)
@@ -129,7 +142,7 @@ module Skill
     end
 
     def used_in_project?(agent)
-      return ruby_llm? if agent.key == 'rubyllm'
+      return ruby_llm? if agent.key == RUBY_LLM
       return File.directory?(File.join(root, agent.project_dir)) if agent.key == FALLBACK
 
       (PROJECT_SIGNS.fetch(agent.key, []) + own_signs(agent)).any? { |sign| File.exist?(File.join(root, sign)) }

data/lib/skill/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Skill
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/skill/workspace.rb

@@ -8,7 +8,7 @@ module Skill
     ROOT_MARKERS = %w[skills.lock Gemfile gems.rb .git package.json].freeze
     AGENT_MARKERS = %w[.agents .claude .codex .cursor .gemini .windsurf AGENTS.md CLAUDE.md GEMINI.md].freeze
 
-    attr_reader :root, :targets, :lock
+    attr_reader :root, :targets, :lock, :moved_lock
 
     # Opens the project around +cwd+, or the home folder with +global+.
     # With +global+ +nil+, uses the home folder when +cwd+ is in no
@@ -17,9 +17,10 @@ module Skill
       project = project_root(cwd, home)
       global = project.nil? if global.nil?
       root = global ? home : project || cwd
+      moved = Lockfile.migrate_global(env: env, home: home) if global
       lock = global ? Lockfile.global_path(env: env, home: home) : File.join(root, Lockfile::NAME)
       new(root: root, targets: Targets.new(root: root, home: home, env: env, global: global),
-          lock: Lockfile.new(lock), limits: limits)
+          lock: Lockfile.new(lock), limits: limits, moved_lock: moved)
     end
 
     # Returns the nearest folder from +cwd+ up holding a lockfile, a
@@ -47,7 +48,10 @@ module Skill
       targets.global?
     end
 
-    def initialize(root:, targets:, lock:, limits:)
+    # +moved_lock+ is where the global lockfile was before this run moved
+    # it, if it did.
+    def initialize(root:, targets:, lock:, limits:, moved_lock: nil)
+      @moved_lock = moved_lock
       @root = root
       @targets = targets
       @lock = lock

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: skill
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Carmine Paolino
@@ -35,6 +35,7 @@ files:
 - lib/skill/commands/agents.rb
 - lib/skill/commands/command.rb
 - lib/skill/commands/find.rb
+- lib/skill/commands/install.rb
 - lib/skill/commands/list.rb
 - lib/skill/commands/remove.rb
 - lib/skill/commands/selection.rb