openclacky 1.0.0 → 1.0.2

data/lib/clacky/default_skills/onboard/scripts/import_external_skills.rb

@@ -0,0 +1,371 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'pathname'
+
+# Import skills from external AI tool installations into ~/.clacky/skills/.
+#
+# Supported sources:
+#   - OpenClaw: ~/.openclaw/skills/, ~/.openclaw/workspace/skills/,
+#               ~/.agents/skills/, ~/.openclaw/workspace/.agents/skills/
+#
+# Each source is imported into a dedicated category subdirectory under ~/.clacky/skills/,
+# e.g. ~/.clacky/skills/openclaw-imports/<skill-name>/. This keeps imported skills
+# isolated from the user's own skills and makes the origin traceable.
+#
+# Usage: ruby import_external_skills.rb [--source <name>] [--dry-run] [--yes]
+#
+# Options:
+#   --source <name>          Import only from the named source (e.g. "openclaw").
+#                            Defaults to all supported sources.
+#   --dry-run                Preview what would be imported without making any changes.
+#   --yes                    Skip confirmation prompt and execute immediately.
+#
+# Exit codes:
+#   0 - success (including "nothing to import" case)
+#   1 - unexpected error
+
+# ---------------------------------------------------------------------------
+# Base class for a single-source importer
+# ---------------------------------------------------------------------------
+class ExternalSkillsImporter
+  # @param target_skills_dir [Pathname] ~/.clacky/skills/
+  # @param category_subdir [String] subdirectory name used to group imported skills
+  # @param dry_run [Boolean] when true, only preview without making changes
+  def initialize(target_skills_dir:, category_subdir:, dry_run: false)
+    @target_skills_dir = target_skills_dir
+    @target_import_dir = target_skills_dir.join(category_subdir)
+    @dry_run           = dry_run
+    @imported          = []
+    @errors            = []
+  end
+
+  # Run the import for this source.
+  # @return [Integer] number of skills imported (or would be imported in dry-run mode)
+  def run
+    unless source_available?
+      puts "[INFO] #{source_label} not found - skipping."
+      return 0
+    end
+
+    skills = discover_skills
+    if skills.empty?
+      puts "[INFO] No #{source_label} skills found - nothing to import."
+      return 0
+    end
+
+    skills.each { |skill| process_skill(skill) }
+
+    @imported.size
+  end
+
+  # Errors encountered during this import run.
+  # @return [Array<String>]
+  def errors
+    @errors.dup
+  end
+
+  # Imported skill records for reporting.
+  # @return [Array<Hash>]
+  def imported
+    @imported.dup
+  end
+
+  # Human-readable name for this source (used in output messages).
+  # Subclasses must override.
+  # @return [String]
+  private def source_label
+    raise NotImplementedError
+  end
+
+  # Return true when the source root directory exists on this machine.
+  # Subclasses must override.
+  # @return [Boolean]
+  private def source_available?
+    raise NotImplementedError
+  end
+
+  # Discover all valid skill directories from the external source.
+  # Each element must be a Hash with at least: { name:, source_dir:, origin: }
+  # Subclasses must override.
+  # @return [Array<Hash>]
+  private def discover_skills
+    raise NotImplementedError
+  end
+
+  # Process a single skill: record it for preview, and copy if not in dry-run mode.
+  #
+  # @param skill [Hash] { name:, source_dir:, origin: }
+  private def process_skill(skill)
+    name       = skill[:name]
+    source_dir = Pathname.new(skill[:source_dir])
+    dest_dir   = @target_import_dir.join(name)
+
+    action = dest_dir.exist? ? 'updated' : 'imported'
+    description = read_description(source_dir.join('SKILL.md'))
+
+    @imported << {
+      name:        name,
+      action:      action,
+      description: description,
+      dest:        dest_dir,
+      source_dir:  source_dir,
+      origin:      skill[:origin]
+    }
+
+    return if @dry_run
+
+    copy_skill(name, source_dir, dest_dir, action)
+  rescue StandardError => e
+    @errors << "Failed to process '#{name}': #{e.message}"
+  end
+
+  # Copy a single skill directory into @target_import_dir.
+  # Existing destinations are removed first so re-running is idempotent.
+  #
+  # @param name [String]
+  # @param source_dir [Pathname]
+  # @param dest_dir [Pathname]
+  # @param action [String] 'imported' or 'updated'
+  private def copy_skill(name, source_dir, dest_dir, action)
+    FileUtils.mkdir_p(@target_import_dir)
+    FileUtils.rm_rf(dest_dir) if dest_dir.exist?
+    FileUtils.mkdir_p(dest_dir)
+
+    # Copy all contents: SKILL.md, scripts/, assets/, etc.
+    source_dir.children.each { |child| FileUtils.cp_r(child, dest_dir) }
+  rescue StandardError => e
+    @errors << "Failed to import '#{name}': #{e.message}"
+  end
+
+  # Extract the description field from SKILL.md YAML frontmatter.
+  # @param skill_file [Pathname]
+  # @return [String]
+  private def read_description(skill_file)
+    return 'No description' unless skill_file.exist?
+
+    content = skill_file.read
+    return $1.strip if content =~ /\A---\s*\n.*?^description:\s*(.+)$/m
+
+    'No description'
+  rescue StandardError
+    'No description'
+  end
+end
+
+# ---------------------------------------------------------------------------
+# OpenClaw importer
+# ---------------------------------------------------------------------------
+class OpenClawImporter < ExternalSkillsImporter
+  SOURCE_NAME          = 'openclaw'
+  DEFAULT_OPENCLAW_DIR = File.join(Dir.home, '.openclaw')
+
+  # @param kwargs forwarded to ExternalSkillsImporter
+  def initialize(**kwargs)
+    super(category_subdir: 'openclaw-imports', **kwargs)
+    @openclaw_dir = Pathname.new(DEFAULT_OPENCLAW_DIR).expand_path
+  end
+
+  private def source_label
+    'OpenClaw (~/.openclaw)'
+  end
+
+  private def source_available?
+    @openclaw_dir.exist?
+  end
+
+  # Returns all directories that may contain OpenClaw skills.
+  # Each entry is a hash: { root: Pathname, layout: :flat }
+  #
+  # Mirrors the four sources from hermes openclaw_to_hermes.py:
+  #   - ~/.openclaw/workspace/skills/             (workspace skills)
+  #   - ~/.openclaw/skills/                        (managed/shared skills)
+  #   - ~/.agents/skills/                          (personal cross-project skills)
+  #   - ~/.openclaw/workspace/.agents/skills/      (project-level shared skills)
+  private def source_dirs
+    [
+      @openclaw_dir.join('workspace', 'skills'),
+      @openclaw_dir.join('skills'),
+      Pathname.new(Dir.home).join('.agents', 'skills'),
+      @openclaw_dir.join('workspace', '.agents', 'skills')
+    ].select(&:exist?)
+  end
+
+  private def discover_skills
+    skills = []
+
+    source_dirs.each do |dir|
+      dir.children.select(&:directory?).each do |skill_dir|
+        next unless skill_dir.join('SKILL.md').exist?
+
+        skills << {
+          name:       skill_dir.basename.to_s,
+          source_dir: skill_dir,
+          origin:     dir.basename.to_s
+        }
+      end
+    end
+
+    skills.sort_by { |s| s[:name] }
+  end
+end
+
+# ---------------------------------------------------------------------------
+# Coordinator - runs all enabled importers and prints a combined report
+# ---------------------------------------------------------------------------
+class ExternalSkillsImportRunner
+  # Register new importer classes here to add support for more sources.
+  IMPORTERS = [OpenClawImporter].freeze
+  SOURCES   = IMPORTERS.map { |klass| klass::SOURCE_NAME }.freeze
+
+  # @param sources [Array<String>] subset of SOURCES to run; nil means all
+  # @param target_skills_dir [String]
+  # @param dry_run [Boolean] when true, only preview without making changes
+  # @param yes [Boolean] when true, skip confirmation prompt
+  def initialize(sources: nil,
+                 target_skills_dir: File.join(Dir.home, '.clacky', 'skills'),
+                 dry_run: false,
+                 yes: false)
+    @sources           = (sources || SOURCES) & SOURCES
+    @target_skills_dir = Pathname.new(target_skills_dir).expand_path
+    @dry_run           = dry_run
+    @yes               = yes
+  end
+
+  def run
+    # In dry-run mode: collect plan and print preview only
+    if @dry_run
+      importers = build_importers(dry_run: true)
+      all_imported = []
+      importers.each { |i| i.run; all_imported.concat(i.imported) }
+      print_preview(all_imported, dry_run: true)
+      return all_imported.size
+    end
+
+    # Normal mode: collect plan first, show preview, then confirm
+    preview_importers = build_importers(dry_run: true)
+    all_preview = []
+    preview_importers.each { |i| i.run; all_preview.concat(i.imported) }
+
+    if all_preview.empty?
+      puts 'Nothing to import.'
+      return 0
+    end
+
+    print_preview(all_preview, dry_run: false)
+
+    unless @yes || confirm?
+      puts 'Import cancelled.'
+      return 0
+    end
+
+    # Execute the actual import
+    importers = build_importers(dry_run: false)
+    all_imported = []
+    all_errors   = []
+
+    importers.each do |importer|
+      importer.run
+      all_imported.concat(importer.imported)
+      all_errors.concat(importer.errors)
+    end
+
+    print_summary(all_imported, all_errors)
+    all_imported.size
+  end
+
+  private def build_importers(dry_run:)
+    common = { target_skills_dir: @target_skills_dir, dry_run: dry_run }
+
+    IMPORTERS
+      .select { |klass| @sources.include?(klass::SOURCE_NAME) }
+      .map { |klass| klass.new(**common) }
+  end
+
+  # Print a Hermes-style preview of what would be / will be imported.
+  # @param skills [Array<Hash>]
+  # @param dry_run [Boolean]
+  private def print_preview(skills, dry_run:)
+    if dry_run
+      puts 'Dry Run Results'
+      puts '  No files will be modified. This is a preview of what would happen.'
+    else
+      puts 'Import Preview'
+      puts '  The following skills will be imported/updated:'
+    end
+    puts
+
+    if skills.empty?
+      puts '  (nothing to import)'
+    else
+      label_width = skills.map { |s| s[:origin].length }.max || 0
+      skills.each do |s|
+        action_marker = s[:action] == 'updated' ? '~' : '✓'
+        puts "  #{action_marker} Would import:  #{s[:origin].ljust(label_width)}  →  #{s[:dest]}"
+      end
+    end
+
+    puts
+    puts "  Summary: #{skills.size} skill(s) would be #{dry_run ? 'imported' : 'imported/updated'}"
+    puts
+  end
+
+  # Print summary after actual import.
+  private def print_summary(imported, errors)
+    puts '=' * 60
+
+    if imported.empty? && errors.empty?
+      puts 'Nothing was imported.'
+    elsif imported.any?
+      puts "Import complete! #{imported.size} skill(s) ready:\n\n"
+      imported.each do |s|
+        action_label = s[:action] == 'updated' ? '[updated]' : '[new]'
+        puts "  #{action_label} #{s[:name]}"
+        puts "    #{s[:description]}"
+        puts "    -> #{s[:dest]}"
+        puts
+      end
+      puts 'Skills will be available automatically next time Clacky starts.'
+    end
+
+    if errors.any?
+      puts 'Errors:'
+      errors.each { |e| puts "  - #{e}" }
+    end
+
+    puts '=' * 60
+  end
+
+  # Prompt user for confirmation.
+  # @return [Boolean]
+  private def confirm?
+    print 'Proceed with import? [y/N] '
+    $stdout.flush
+    answer = $stdin.gets&.strip&.downcase
+    answer == 'y' || answer == 'yes'
+  end
+end
+
+# -- Entry point ------------------------------------------------------------
+if __FILE__ == $PROGRAM_NAME
+  require 'optparse'
+
+  options = {}
+
+  OptionParser.new do |opts|
+    opts.banner = "Usage: #{File.basename($PROGRAM_NAME)} [options]"
+    opts.on('--source NAME',
+            "Import only from NAME (e.g. openclaw). Supported: #{ExternalSkillsImportRunner::SOURCES.join(', ')}") do |name|
+      options[:sources] = [name]
+    end
+    opts.on('--dry-run', 'Preview what would be imported without making any changes.') do
+      options[:dry_run] = true
+    end
+    opts.on('--yes', '-y', 'Skip confirmation prompt and execute immediately.') do
+      options[:yes] = true
+    end
+  end.parse!
+
+  ExternalSkillsImportRunner.new(**options).run
+end

data/lib/clacky/default_skills/onboard/scripts/install_builtin_skills.rb

@@ -0,0 +1,175 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Install builtin skills into ~/.clacky/skills/.
+#
+# Fetches the server-curated builtin list from GET /api/v1/skills/builtin on
+# the openclacky platform (public, no auth), then downloads and installs each
+# skill's zip package in parallel (5 workers, 30s total timeout).
+#
+# The "builtin" whitelist is enforced server-side — this script takes no
+# filter flags. Admin toggles the `builtin` flag per skill on the platform.
+#
+# Called by onboard skill: `ruby install_builtin_skills.rb`
+#
+# Output:
+#   - Diagnostics → STDERR
+#   - Last line of STDOUT → JSON: {"installed":N,"attempted":N,"skipped_existing":N}
+#   - Exit code: always 0
+
+require 'uri'
+require 'net/http'
+require 'json'
+require 'timeout'
+
+# Reuse the downloader/extractor/installer from the skill-add skill.
+# Physical relocation to lib/clacky/ is deferred until a third caller appears.
+require_relative '../../skill-add/scripts/install_from_zip'
+
+class BuiltinSkillsInstaller
+  PRIMARY_HOST     = ENV.fetch('CLACKY_LICENSE_SERVER', 'https://www.openclacky.com')
+  FALLBACK_HOST    = 'https://openclacky.up.railway.app'
+  API_HOSTS        = ENV['CLACKY_LICENSE_SERVER'] ? [PRIMARY_HOST] : [PRIMARY_HOST, FALLBACK_HOST]
+  API_PATH         = '/api/v1/skills/builtin'
+  API_OPEN_TIMEOUT = 5
+  API_READ_TIMEOUT = 10
+  CONCURRENCY      = 5
+
+  def initialize
+    @target_dir        = File.join(Dir.home, '.clacky', 'skills')
+    @per_skill_timeout = 10
+    @total_timeout     = 30
+
+    @installed         = 0
+    @skipped_existing  = 0
+    @attempted         = 0
+    @errors            = []
+    @mutex             = Mutex.new
+  end
+
+  def run
+    skills = fetch_skill_list
+    if skills.nil? || skills.empty?
+      emit_summary
+      return
+    end
+
+    install_concurrently(skills)
+  ensure
+    emit_summary
+  end
+
+  # --- Internals -------------------------------------------------------------
+
+  # Returns an array of skill hashes, or nil on total failure.
+  private def fetch_skill_list
+    API_HOSTS.each do |host|
+      begin
+        uri = URI.parse(host + API_PATH)
+        Net::HTTP.start(uri.host, uri.port,
+                        use_ssl:      uri.scheme == 'https',
+                        open_timeout: API_OPEN_TIMEOUT,
+                        read_timeout: API_READ_TIMEOUT) do |http|
+          response = http.request(Net::HTTP::Get.new(uri.request_uri))
+          if response.code.to_i == 200
+            payload = JSON.parse(response.body)
+            return Array(payload['skills'])
+          else
+            @errors << "API #{host}: HTTP #{response.code}"
+          end
+        end
+      rescue StandardError => e
+        @errors << "API #{host}: #{e.class}: #{e.message}"
+      end
+    end
+    nil
+  end
+
+  # Install skills in parallel, bounded by CONCURRENCY and @total_timeout.
+  # Workers pull from a shared queue and self-check the deadline, so the
+  # global timeout is enforced without killing threads mid-download (which
+  # would leak temp dirs). Whatever finishes before the deadline stays
+  # installed; the rest is recovered on the next onboard run via skip_if_exists.
+  private def install_concurrently(skills)
+    queue = Queue.new
+    skills.each { |s| queue << s }
+
+    deadline    = Time.now + @total_timeout
+    worker_pool = [CONCURRENCY, skills.size].min
+
+    workers = Array.new(worker_pool) do
+      Thread.new do
+        loop do
+          break if Time.now >= deadline
+          skill = queue.pop(true) rescue nil    # non-blocking pop
+          break if skill.nil?
+          install_one(skill)
+        end
+      end
+    end
+
+    workers.each(&:join)
+
+    # If the deadline cut us off with items still in the queue, record it.
+    remaining = queue.size
+    if remaining.positive?
+      @mutex.synchronize do
+        @errors << "overall timeout after #{@total_timeout}s " \
+                   "(installed=#{@installed}, attempted=#{@attempted}, remaining=#{remaining})"
+      end
+    end
+  end
+
+  # Install one skill entry (hash from the API payload).
+  # Bounded by @per_skill_timeout; any failure is swallowed into @errors.
+  # Thread-safe: all shared state writes go through @mutex.
+  private def install_one(skill)
+    name         = skill['name'].to_s
+    download_url = skill['download_url'].to_s
+
+    @mutex.synchronize { @attempted += 1 }
+
+    if name.empty? || download_url.empty?
+      @mutex.synchronize do
+        @errors << "skill payload missing name or download_url: #{skill.inspect}"
+      end
+      return
+    end
+
+    Timeout.timeout(@per_skill_timeout) do
+      installer = ZipSkillInstaller.new(
+        download_url,
+        skill_name:     name,
+        target_dir:     @target_dir,
+        skip_if_exists: true
+      )
+      result = installer.perform
+      @mutex.synchronize do
+        @installed        += result[:installed].size
+        @skipped_existing += result[:skipped].size
+        @errors.concat(result[:errors]) if result[:errors].any?
+      end
+    end
+  rescue Timeout::Error
+    @mutex.synchronize { @errors << "#{name}: install timeout after #{@per_skill_timeout}s" }
+  rescue StandardError => e
+    @mutex.synchronize { @errors << "#{name}: #{e.class}: #{e.message}" }
+  end
+
+  # Diagnostics to stderr; single-line JSON summary to stdout.
+  # The caller (onboard) should parse the LAST stdout line.
+  private def emit_summary
+    unless @errors.empty?
+      warn '[install_builtin_skills] non-fatal errors:'
+      @errors.each { |e| warn "  - #{e}" }
+    end
+    puts JSON.generate(
+      installed:        @installed,
+      attempted:        @attempted,
+      skipped_existing: @skipped_existing
+    )
+  end
+end
+
+# ── Entry point ───────────────────────────────────────────────────────────────
+BuiltinSkillsInstaller.new.run if __FILE__ == $0

data/lib/clacky/default_skills/skill-add/scripts/install_from_zip.rb

@@ -19,7 +19,7 @@ require 'find'
 class ZipSkillInstaller
   ZIP_URL_PATTERN = %r{^https?://.+\.zip(\?.*)?$}i
 
-  def initialize(zip_source, skill_name: nil, target_dir: nil)
+  def initialize(zip_source, skill_name: nil, target_dir: nil, skip_if_exists: false)
     @zip_source = zip_source
     @local_path = local_zip_path?(zip_source)
     # skill_name can be provided explicitly (e.g. slug from the store API).
@@ -27,45 +27,72 @@ class ZipSkillInstaller
     # "ui-ux-pro-max-1.0.0.zip" → "ui-ux-pro-max".
     @skill_name = skill_name || infer_skill_name(zip_source)
     @target_dir = target_dir || File.join(Dir.home, '.clacky', 'skills')
+    # When true, existing skill directories are preserved and the install for
+    # that specific skill is skipped (recorded in @skipped_skills).
+    # Default false keeps the legacy "overwrite" behaviour for `install`.
+    @skip_if_exists   = skip_if_exists
+    # Suppresses user-facing puts for programmatic callers (set by `perform`).
+    @silent           = false
     @installed_skills = []
-    @errors = []
+    @skipped_skills   = []
+    @errors           = []
   end
 
-  # Main installation entry point.
+  # Programmatic entry point for library-style callers (e.g. onboard pre-install).
+  #
+  # Unlike `install`, this method:
+  #   - does NOT print user-facing output
+  #   - does NOT call `exit` on failure (raises instead)
+  #   - returns a result hash: { installed: [...], skipped: [...], errors: [...] }
+  #
+  # The caller is responsible for rendering feedback and deciding whether any
+  # error is fatal.
+  def perform
+    @silent = true
+    do_install
+    { installed: @installed_skills, skipped: @skipped_skills, errors: @errors }
+  end
+
+  # Main installation entry point (CLI). Prints progress, prints a final
+  # report, and calls `exit` on failure. Use `perform` for programmatic use.
   def install
+    do_install
+    report_results
+  rescue ArgumentError => e
+    puts "Error: #{e.message}"
+    exit 1
+  rescue StandardError => e
+    puts "Error: Installation failed: #{e.message}"
+    exit 1
+  end
+
+  # Shared core used by both `install` (CLI) and `perform` (library).
+  # Raises on invalid input; the caller decides how to surface errors.
+  private def do_install
     if @local_path
       # Install directly from a local zip file — no download needed.
-      # Expand tilde in path (e.g. ~/Downloads/skill.zip)
+      # Expand tilde in path (e.g. ~/Downloads/skill.zip).
       expanded = File.expand_path(@zip_source)
-      raise ArgumentError, "File not found: #{@zip_source}" unless File.exist?(expanded)
-      raise ArgumentError, "Not a zip file: #{@zip_source}" unless expanded.end_with?('.zip')
+      raise ArgumentError, "File not found: #{@zip_source}"  unless File.exist?(expanded)
+      raise ArgumentError, "Not a zip file: #{@zip_source}"  unless expanded.end_with?('.zip')
 
       Dir.mktmpdir('clacky-zip-') do |tmpdir|
         extract_zip(expanded, tmpdir)
-        extracted_dir = File.join(tmpdir, 'extracted')
-        discover_and_install_skills(extracted_dir)
+        discover_and_install_skills(File.join(tmpdir, 'extracted'))
       end
     else
       # Install from a remote URL.
       unless valid_zip_url?
-        raise ArgumentError, "Invalid zip source: #{@zip_source}\nProvide an http(s) URL ending with .zip, or an absolute path to a local zip file."
+        raise ArgumentError, "Invalid zip source: #{@zip_source}\n" \
+                             "Provide an http(s) URL ending with .zip, or an absolute path to a local zip file."
       end
 
       Dir.mktmpdir('clacky-zip-') do |tmpdir|
         zip_path = download_zip(tmpdir)
         extract_zip(zip_path, tmpdir)
-        extracted_dir = File.join(tmpdir, 'extracted')
-        discover_and_install_skills(extracted_dir)
+        discover_and_install_skills(File.join(tmpdir, 'extracted'))
       end
     end
-
-    report_results
-  rescue ArgumentError => e
-    puts "❌ #{e.message}"
-    exit 1
-  rescue StandardError => e
-    puts "❌ Installation failed: #{e.message}"
-    exit 1
   end
 
   # Return true if the source looks like a local file path (absolute or relative ending in .zip).
@@ -93,8 +120,10 @@ class ZipSkillInstaller
 
   # Download the zip file to tmpdir and return its local path.
   private def download_zip(tmpdir)
-    puts "⬇️  Downloading skill package..."
-    puts "   #{@zip_source}"
+    unless @silent
+      puts "Downloading skill package..."
+      puts "   #{@zip_source}"
+    end
 
     zip_path = File.join(tmpdir, 'skill.zip')
     uri = URI.parse(@zip_source)
@@ -129,7 +158,7 @@ class ZipSkillInstaller
 
   # Extract the zip archive into <tmpdir>/extracted/.
   private def extract_zip(zip_path, tmpdir)
-    puts "📂 Extracting package..."
+    puts "Extracting package..." unless @silent
     extracted_dir = File.join(tmpdir, 'extracted')
     FileUtils.mkdir_p(extracted_dir)
 
@@ -184,7 +213,11 @@ class ZipSkillInstaller
     target_path = File.join(@target_dir, name)
 
     if File.exist?(target_path)
-      puts "♻️  Skill '#{name}' already exists — overwriting..."
+      if @skip_if_exists
+        @skipped_skills << { name: name, path: target_path, reason: 'already exists' }
+        return
+      end
+      puts "Skill '#{name}' already exists — overwriting..." unless @silent
       FileUtils.rm_rf(target_path)
     end
 
@@ -218,7 +251,7 @@ class ZipSkillInstaller
     puts "\n" + "=" * 60
 
     if @installed_skills.empty?
-      puts "❌ No skills were installed."
+      puts "No skills were installed."
       if @errors.any?
         puts "\nErrors:"
         @errors.each { |e| puts "   • #{e}" }
@@ -226,7 +259,7 @@ class ZipSkillInstaller
       exit 1
     end
 
-    puts "✅ Installation complete!"
+    puts "Installation complete!"
     puts "\nInstalled #{@installed_skills.size} skill(s):\n\n"
     @installed_skills.each do |skill|
       puts "   ✓ #{skill[:name]}"
@@ -236,7 +269,7 @@ class ZipSkillInstaller
     end
 
     if @errors.any?
-      puts "⚠️  Warnings:"
+      puts "Warnings:"
       @errors.each { |e| puts "   • #{e}" }
       puts
     end