skill 0.1.0

data/lib/skill/http.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'openssl'
+require 'uri'
+
+module Skill
+  # A small HTTPS client on Net::HTTP: follows redirects, stops reading at a
+  # byte limit, and sends credentials only to the host they were given for.
+  # Net::HTTP reads proxies from +https_proxy+ and +no_proxy+.
+  class HTTP
+    Response = Struct.new(:status, :body, :headers, keyword_init: true)
+
+    MAX_REDIRECTS = 5
+
+    def initialize(user_agent: "skill/#{VERSION} (+https://github.com/crmne/skill)")
+      @user_agent = user_agent
+    end
+
+    # Fetches +url+ and returns a Response whose body is a String, or, when
+    # +io+ is given, writes the body to +io+. Raises NetworkError when the
+    # body is larger than +limit+ bytes or the request fails, and leaves
+    # statuses other than redirects to the caller. Only a 200 body goes to
+    # +io+; any other is returned as a String.
+    def get(url, limit:, headers: {}, io: nil)
+      uri = URI(url)
+      credentials_host = uri.host
+      MAX_REDIRECTS.succ.times do
+        raise NetworkError, "Refusing to download over plain HTTP: #{redacted(uri)}" unless uri.scheme == 'https'
+
+        sent = uri.host == credentials_host ? headers : headers.reject { |key, _| key.casecmp?('authorization') }
+        response = request(uri, sent, limit, io)
+        return response unless (300..399).cover?(response.status) && response.headers['location']
+
+        uri = URI.join(uri.to_s, response.headers['location'])
+      end
+      raise NetworkError, "Too many redirects from #{redacted(URI(url))}"
+    rescue URI::InvalidURIError => e
+      raise NetworkError, "Invalid address: #{e.message}"
+    end
+
+    private
+
+    def request(uri, headers, limit, io)
+      Net::HTTP.start(uri.host, uri.port, use_ssl: true, open_timeout: 15, read_timeout: 60) do |http|
+        get = Net::HTTP::Get.new(uri)
+        get['User-Agent'] = @user_agent
+        headers.each { |key, value| get[key] = value }
+        http.request(get) { |response| return read(response, limit, io) }
+      end
+    rescue SocketError, SystemCallError, IOError, Timeout::Error, OpenSSL::SSL::SSLError, Net::HTTPBadResponse => e
+      raise NetworkError, "Could not reach #{uri.host}: #{e.class}"
+    end
+
+    def read(response, limit, io)
+      status = response.code.to_i
+      headers = { 'location' => response['location'], 'content-type' => response['content-type'] }
+      return Response.new(status: status, body: '', headers: headers) if (300..399).cover?(status)
+
+      io = nil unless status == 200
+      body = io ? nil : String.new(encoding: Encoding::BINARY)
+      size = 0
+      response.read_body do |chunk|
+        size += chunk.bytesize
+        raise TooLargeError, "#{response.uri&.host} sent more than #{limit} bytes" if size > limit
+
+        io ? io.write(chunk) : body << chunk
+      end
+      Response.new(status: status, body: body, headers: headers)
+    end
+
+    def redacted(uri)
+      "#{uri.scheme}://#{uri.host}#{uri.path}"
+    end
+  end
+end

data/lib/skill/installer.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'securerandom'
+
+module Skill
+  # Copies skill folders into target folders. Each copy is built beside its
+  # target, under a hidden name, and swapped in with renames once every copy
+  # of every skill is ready, so a failure leaves the installed skills as
+  # they were.
+  class Installer
+    # One skill to copy: the name it installs as, its Tree, the folders it
+    # goes into, and whether its files keep their executable bits. +entry+
+    # and +labels+ are for the caller's bookkeeping.
+    Copy = Struct.new(:name, :tree, :targets, :executable, :entry, :labels, keyword_init: true)
+
+    # Installs every Copy in +copies+ into each of its target folders.
+    def install(copies)
+      staged = {}
+      copies.each do |copy|
+        copy.targets.each do |target|
+          FileUtils.mkdir_p(target)
+          staging = hidden(target, copy.name)
+          staged[staging] = destination(target, copy.name)
+          stage(copy, staging)
+        end
+      end
+      swapped = {}
+      staged.each { |staging, final| swapped[final] = swap(staging, final) }
+      swapped.each_value { |backup| FileUtils.rm_rf(backup) if backup }
+    rescue StandardError
+      swapped&.reverse_each { |final, backup| restore(final, backup) }
+      staged&.each_key { |staging| FileUtils.rm_rf(staging) }
+      raise
+    end
+
+    # Deletes the skill +name+ from each folder in +targets+.
+    def remove(name, targets)
+      targets.each do |target|
+        final = destination(target, name)
+        next unless File.exist?(final) || File.symlink?(final)
+
+        trash = hidden(target, "#{name}-removed")
+        File.rename(final, trash)
+        FileUtils.rm_rf(trash)
+      end
+    end
+
+    # Returns the folder +name+ installs to inside +target+.
+    def self.destination(target, name)
+      raise UnsafeError, "#{name.inspect} is not a skill name" unless Manifest.valid_name?(name)
+
+      File.join(File.expand_path(target), name)
+    end
+
+    private
+
+    def destination(target, name)
+      self.class.destination(target, name)
+    end
+
+    def stage(copy, staging)
+      Dir.mkdir(staging, 0o755)
+      copy.tree.entries.each do |relative, entry|
+        source = File.join(copy.tree.root, relative)
+        file = File.join(staging, relative)
+        FileUtils.mkdir_p(File.dirname(file))
+        FileUtils.cp(source, file)
+        File.chmod(copy.executable && entry.executable ? 0o755 : 0o644, file)
+      end
+    end
+
+    def swap(staging, final)
+      backup = nil
+      if File.exist?(final) || File.symlink?(final)
+        backup = hidden(File.dirname(final), "#{File.basename(final)}-previous")
+        File.rename(final, backup)
+      end
+      File.rename(staging, final)
+      backup
+    end
+
+    def restore(final, backup)
+      FileUtils.rm_rf(final)
+      File.rename(backup, final) if backup && File.exist?(backup)
+    end
+
+    def hidden(target, name)
+      File.join(target, ".skill-#{name}-#{SecureRandom.hex(4)}")
+    end
+  end
+end

data/lib/skill/limits.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Skill
+  # How much the command downloads, extracts, and installs at most. Each
+  # limit can be raised with an environment variable, for sources you trust.
+  #
+  # GitHub serves a whole commit as one archive and skills are found in it,
+  # so the download and extraction limits fit popular repositories, whose
+  # tests and recordings run to hundreds of megabytes. Both stream to disk,
+  # never into memory. The per-skill limits stay tight, since only the
+  # chosen skills' folders are installed.
+  class Limits
+    DEFAULTS = {
+      download_bytes: ['SKILL_MAX_DOWNLOAD_BYTES', 512 * 1024 * 1024],
+      extract_bytes: ['SKILL_MAX_EXTRACT_BYTES', 2 * 1024 * 1024 * 1024],
+      extract_files: ['SKILL_MAX_EXTRACT_FILES', 100_000],
+      skill_bytes: ['SKILL_MAX_SKILL_BYTES', 16 * 1024 * 1024],
+      skill_files: ['SKILL_MAX_SKILL_FILES', 2_000]
+    }.freeze
+
+    attr_reader(*DEFAULTS.keys)
+
+    # Returns +message+ followed by how to raise the +key+ limit, so a refusal
+    # says what to do about it.
+    def self.exceeded(key, message)
+      "#{message}. Set #{DEFAULTS.fetch(key).first} higher for a source you trust"
+    end
+
+    def initialize(env = ENV, **overrides)
+      DEFAULTS.each do |key, (variable, default)|
+        value = overrides.fetch(key) { env[variable] ? Integer(env[variable], 10) : default }
+        raise UsageError, "#{variable} must be a positive number" unless value.positive?
+
+        instance_variable_set(:"@#{key}", value)
+      end
+    rescue ArgumentError
+      raise UsageError, 'SKILL_MAX_* variables must be whole numbers of bytes or files'
+    end
+  end
+end

data/lib/skill/lockfile.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+
+module Skill
+  # +skills.lock+: what each installed skill came from, so +update+ can
+  # 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+).
+  #
+  #   {
+  #     "version": 1,
+  #     "skills": {
+  #       "pdf": {
+  #         "source": "anthropics/skills",
+  #         "ref": null,
+  #         "ref_type": "branch",
+  #         "commit": "dbd4588f9e1033efb41dad4bef2f7947c8993d44",
+  #         "path": "skills/pdf",
+  #         "plugin": "document-skills",
+  #         "digest": "sha256-...",
+  #         "executable": false,
+  #         "targets": [".claude/skills", "app/skills"]
+  #       }
+  #     }
+  #   }
+  class Lockfile
+    NAME = 'skills.lock'
+    VERSION = 1
+    KEYS = %w[source ref ref_type commit path plugin digest executable targets].freeze
+
+    attr_reader :path, :skills
+
+    # 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)
+    end
+
+    def initialize(path)
+      @path = path
+      @skills = File.exist?(path) ? parse(File.read(path, encoding: 'UTF-8')) : {}
+    end
+
+    def [](name)
+      skills[name]
+    end
+
+    def include?(name)
+      skills.key?(name)
+    end
+
+    def names
+      skills.keys
+    end
+
+    # Records +entry+, a Hash with the keys of KEYS, for the skill +name+.
+    def []=(name, entry)
+      clean = entry.transform_keys(&:to_s).slice(*KEYS)
+      clean['targets'] = Array(clean['targets']).uniq.sort
+      clean.delete('plugin') if clean['plugin'].nil?
+      skills[name] = clean
+    end
+
+    def delete(name)
+      skills.delete(name)
+    end
+
+    # Writes the lockfile, or deletes it when it records nothing.
+    def save
+      if skills.empty?
+        FileUtils.rm_f(path)
+        return
+      end
+
+      FileUtils.mkdir_p(File.dirname(path))
+      sorted = skills.sort.to_h { |name, entry| [name, ordered(entry)] }
+      temporary = "#{path}.#{Process.pid}.tmp"
+      File.write(temporary, "#{JSON.pretty_generate('version' => VERSION, 'skills' => sorted)}\n")
+      File.rename(temporary, path)
+    ensure
+      FileUtils.rm_f(temporary) if temporary
+    end
+
+    private
+
+    def ordered(entry)
+      KEYS.select { |key| entry.key?(key) }.to_h { |key| [key, entry[key]] }
+    end
+
+    def parse(text)
+      data = JSON.parse(text)
+      unless data.is_a?(Hash) && data['skills'].is_a?(Hash)
+        raise Error, "#{path} is not a skills lockfile. Fix or delete it"
+      end
+      raise Error, "#{path} was written by a newer skill. Run `gem update skill`" if data['version'].to_i > VERSION
+
+      data['skills'].each do |name, entry|
+        raise Error, "#{path} records an invalid skill name, #{name.inspect}" unless Manifest.valid_name?(name)
+        unless entry.is_a?(Hash) && entry['source'].is_a?(String)
+          raise Error,
+                "#{path} records #{name} without a source"
+        end
+      end
+      data['skills']
+    rescue JSON::ParserError
+      raise Error, "#{path} is not valid JSON. Resolve any merge conflict in it, or delete it and add the skills again"
+    end
+  end
+end

data/lib/skill/manifest.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'yaml'
+
+module Skill
+  # A skill's +SKILL.md+, checked against the Agent Skills specification
+  # (https://agentskills.io/specification) the way RubyLLM checks it: YAML
+  # front matter with a +name+ of lowercase letters, digits, and single
+  # hyphens, at most 64 characters, and a +description+ of at most 1,024.
+  class Manifest
+    FILE = 'SKILL.md'
+    MAX_NAME = 64
+    MAX_DESCRIPTION = 1024
+    MAX_COMPATIBILITY = 500
+    MAX_BYTES = 1024 * 1024
+    FRONT_MATTER = /\A---[ \t]*\r?\n(.*?)^---[ \t]*(?:\r?\n|\z)/m
+    NAME = /\A[a-z0-9]+(?:-[a-z0-9]+)*\z/
+
+    attr_reader :name, :description, :metadata, :path
+
+    # Reads the +SKILL.md+ in the folder at +path+. Raises InvalidSkillError
+    # when it is missing or breaks the specification.
+    def self.load(path)
+      new(path)
+    end
+
+    # Returns whether +name+ is a valid skill name.
+    def self.valid_name?(name)
+      name.is_a?(String) && name.length <= MAX_NAME && name.match?(NAME)
+    end
+
+    def initialize(path)
+      @path = path.to_s
+      file = File.join(@path, FILE)
+      invalid('is missing') unless File.file?(file) && !File.symlink?(file)
+      invalid("is larger than #{MAX_BYTES} bytes") if File.size(file) > MAX_BYTES
+
+      assign(front_matter(File.read(file, encoding: 'UTF-8')))
+    end
+
+    # Returns whether the front matter marks the skill internal, which hides
+    # it unless it is asked for by name.
+    def internal?
+      %w[true 1 yes].include?(metadata['internal'].to_s.downcase)
+    end
+
+    private
+
+    def front_matter(content)
+      content = content.delete_prefix("\u{FEFF}")
+      invalid('is not valid UTF-8') unless content.valid_encoding?
+      match = FRONT_MATTER.match(content)
+      invalid('must start with YAML front matter between --- lines') unless match
+
+      data = YAML.safe_load(match[1], permitted_classes: [Date, Time], aliases: false)
+      invalid('front matter must be a YAML mapping') unless data.is_a?(Hash)
+      data.transform_keys(&:to_s)
+    rescue Psych::Exception => e
+      invalid("front matter is not valid YAML: #{e.message.lines.first.strip}")
+    end
+
+    def assign(data)
+      @name = required(data, 'name', MAX_NAME)
+      unless @name.match?(NAME)
+        invalid("name #{@name.inspect} must be lowercase letters, digits, and single hyphens between them")
+      end
+      @description = required(data, 'description', MAX_DESCRIPTION)
+      optional(data, 'license')
+      optional(data, 'compatibility', MAX_COMPATIBILITY)
+      optional(data, 'allowed-tools')
+      @metadata = metadata_of(data['metadata'])
+    end
+
+    def required(data, key, limit)
+      value = data[key]
+      invalid("needs a #{key}") if value.nil? || (value.is_a?(String) && value.strip.empty?)
+
+      optional(data, key, limit)
+    end
+
+    def optional(data, key, limit = nil)
+      value = data[key]
+      return if value.nil?
+
+      invalid("#{key} must be a string") unless value.is_a?(String)
+      invalid("#{key} must not be empty") if value.strip.empty?
+      invalid("#{key} must be at most #{limit} characters") if limit && value.length > limit
+      value.strip
+    end
+
+    def metadata_of(value)
+      return {}.freeze if value.nil?
+
+      invalid('metadata must be a mapping') unless value.is_a?(Hash)
+      value.to_h { |key, entry| [key.to_s, entry.to_s] }.freeze
+    end
+
+    def invalid(reason)
+      raise InvalidSkillError, "#{File.join(@path, FILE)} #{reason}"
+    end
+  end
+end

data/lib/skill/session.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Skill
+  # What one run of the command shares: its streams, environment, folders,
+  # and the downloads it made, which #cleanup deletes.
+  class Session
+    attr_reader :env, :cwd, :home
+
+    def initialize(out:, err:, input:, env:, cwd:, home:, http: nil)
+      @out = out
+      @err = err
+      @input = input
+      @env = env
+      @cwd = File.expand_path(cwd)
+      @home = File.expand_path(home)
+      @http = http
+    end
+
+    def say(text = '')
+      @out.puts text
+    end
+
+    # Prints a warning on the error stream: "! " and +text+, yellow on a
+    # terminal.
+    def warn(text)
+      @err.puts err_style.yellow("! #{text}")
+    end
+
+    def error(text)
+      @err.puts "#{err_style.red('skill:')} #{text}"
+    end
+
+    # Returns the Style for standard output.
+    def style
+      @style ||= Style.for(@out, env)
+    end
+
+    # Returns the Style for the error stream.
+    def err_style
+      @err_style ||= Style.for(@err, env)
+    end
+
+    # Asks +question+ on a terminal. Returns +false+ without asking when
+    # input is not a terminal.
+    def confirm?(question)
+      return false unless @input.respond_to?(:tty?) && @input.tty?
+
+      @out.print "#{question} [y/N] "
+      @out.flush
+      @input.gets.to_s.strip.match?(/\Ay(?:es)?\z/i)
+    end
+
+    # 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)
+    end
+
+    def limits
+      @limits ||= Limits.new(env)
+    end
+
+    def http
+      @http ||= HTTP.new
+    end
+
+    def fetcher
+      @fetcher ||= begin
+        require 'tmpdir'
+        @workdir = Dir.mktmpdir('skill-')
+        Fetcher.new(github: GitHub.new(http: http, env: env, limits: limits), limits: limits, workdir: @workdir)
+      end
+    end
+
+    # Returns whether internal skills may be installed without naming them.
+    def internal_skills?
+      %w[1 true].include?(env['INSTALL_INTERNAL_SKILLS'].to_s.downcase)
+    end
+
+    # Deletes everything downloaded during the run.
+    def cleanup
+      return unless @workdir
+
+      require 'fileutils'
+      FileUtils.rm_rf(@workdir)
+    end
+  end
+end

data/lib/skill/source.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Skill
+  # Where skills come from, parsed from what follows +skill add+:
+  #
+  #   owner/repo                         every skill in the repository
+  #   owner/repo@pdf                     one skill, by name
+  #   owner/repo/skills/pdf              one folder of the repository
+  #   owner/repo#v1.2.0                  a branch, tag, or commit
+  #   owner/repo#v1.2.0@pdf              both
+  #   https://github.com/owner/repo/tree/main/skills/pdf
+  #   ./path/to/skills                   a local directory
+  class Source
+    OWNER = /\A[A-Za-z0-9](?:[A-Za-z0-9-]{0,38})\z/
+    REPO = /\A[A-Za-z0-9._-]{1,100}\z/
+    REF = %r{\A(?!-)(?!.*\.\.)(?!.*//)[A-Za-z0-9._/+-]{1,250}(?<![./])\z}
+    GITHUB_URL = %r{\Ahttps?://(?:www\.)?github\.com/([^/]+)/([^/#?]+?)(?:\.git)?(?:/tree/([^/]+)(?:/(.+?))?)?/?\z}
+
+    attr_reader :kind, :owner, :repo, :ref, :subpath, :skills, :path
+
+    class << self
+      # Returns the Source +input+ names, relative paths read from +root+.
+      def parse(input, root: Dir.pwd, ref: nil)
+        text = input.to_s.strip
+        raise UsageError, 'Name a source, such as owner/repo or ./path' if text.empty?
+        return local(text, root) if local?(text)
+
+        text = text.delete_prefix('github:')
+        text, fragment = text.split('#', 2)
+        fragment_ref, fragment_skill = fragment.to_s.split('@', 2)
+        github(text, ref: ref || presence(fragment_ref), skill: presence(fragment_skill))
+      end
+
+      # Returns whether +text+ reads as a local path.
+      def local?(text)
+        text.start_with?('./', '../', '/', '~/', '.\\', '..\\') || %w[. .. ~].include?(text) ||
+          text.match?(%r{\A[A-Za-z]:[\\/]})
+      end
+
+      # Returns a relative path inside a repository, without empty or +.+
+      # segments. Raises UnsafeError for absolute paths and +..+.
+      def clean_path(path)
+        text = path.to_s.tr('\\', '/')
+        if text.start_with?('/') || text.match?(/\A[A-Za-z]:/)
+          raise UnsafeError,
+                "#{path.inspect} is not a relative path"
+        end
+
+        parts = text.split('/').reject { |part| part.empty? || part == '.' }
+        raise UnsafeError, "#{path.inspect} leaves its folder" if parts.include?('..') || text.include?("\0")
+
+        parts.join('/')
+      end
+
+      private
+
+      def presence(value)
+        value unless value.nil? || value.empty?
+      end
+
+      def local(text, root)
+        expanded = File.expand_path(text, root)
+        new(kind: :local, path: expanded)
+      end
+
+      def github(text, ref:, skill:)
+        if (match = GITHUB_URL.match(text))
+          owner, repo, tree_ref, subpath = match.captures
+          return build(owner, repo, ref: ref || tree_ref, subpath: subpath, skill: skill)
+        end
+        raise UsageError, "#{text.inspect} is not a GitHub repository like owner/repo" if text.include?(':')
+
+        shorthand(text, ref: ref, skill: skill)
+      end
+
+      def shorthand(text, ref:, skill:)
+        name, at_skill = text.split('@', 2)
+        owner, repo, *rest = name.split('/')
+        raise UsageError, "#{text.inspect} is not a GitHub repository like owner/repo" unless owner && repo
+
+        build(owner, repo, ref: ref, subpath: rest.join('/'), skill: skill || presence(at_skill))
+      end
+
+      def build(owner, repo, ref:, subpath:, skill:)
+        unless owner.match?(OWNER) && repo.match?(REPO) && !%w[. ..].include?(repo)
+          raise UsageError, "#{owner}/#{repo} is not a GitHub repository name"
+        end
+        raise UsageError, "#{ref.inspect} is not a valid git ref" if ref && !ref.match?(REF)
+
+        skills = skill.to_s.split(',').map(&:strip).reject(&:empty?)
+        new(kind: :github, owner: owner, repo: repo.delete_suffix('.git'), ref: ref,
+            subpath: clean_path(subpath.to_s), skills: skills)
+      end
+    end
+
+    def initialize(kind:, owner: nil, repo: nil, ref: nil, subpath: '', skills: [], path: nil)
+      @kind = kind
+      @owner = owner
+      @repo = repo
+      @ref = ref
+      @subpath = subpath.to_s
+      @skills = skills.freeze
+      @path = path
+      freeze
+    end
+
+    def github?
+      kind == :github
+    end
+
+    def local?
+      kind == :local
+    end
+
+    # Returns the repository as +owner/repo+, or the local path.
+    def name
+      github? ? "#{owner}/#{repo}" : path
+    end
+
+    # Returns the repository's web address, or +nil+ for a local directory.
+    def url
+      "https://github.com/#{owner}/#{repo}" if github?
+    end
+
+    # Returns a copy with another ref.
+    def with_ref(ref)
+      self.class.new(kind: kind, owner: owner, repo: repo, ref: ref, subpath: subpath, skills: skills, path: path)
+    end
+
+    def to_s
+      text = name
+      text += "/#{subpath}" if github? && !subpath.empty?
+      text += "##{ref}" if ref
+      text
+    end
+  end
+end

data/lib/skill/style.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Skill
+  # Colors text for a terminal. Off unless the stream is a terminal, and off
+  # when +NO_COLOR+ is set or +TERM+ is +dumb+, so piped output stays plain.
+  class Style
+    CODES = { bold: [1, 22], dim: [2, 22], red: [31, 39], green: [32, 39], yellow: [33, 39] }.freeze
+
+    # Returns a Style for +stream+, colored when it is a terminal and
+    # +env+ allows it.
+    def self.for(stream, env)
+      terminal = stream.respond_to?(:tty?) && stream.tty?
+      new(terminal && env['NO_COLOR'].to_s.empty? && env['TERM'] != 'dumb')
+    end
+
+    def initialize(color)
+      @color = color
+    end
+
+    def color?
+      @color
+    end
+
+    CODES.each do |name, (on, off)|
+      define_method(name) { |text| @color ? "\e[#{on}m#{text}\e[#{off}m" : text.to_s }
+    end
+  end
+end