shai-cli 0.1.1 → 0.3.0

data/lib/shai/commands/skills.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module Shai
+  module Commands
+    module Skills
+      def self.included(base)
+        base.class_eval do
+          desc "skills [SUBCOMMAND]", "Manage AI agent skills"
+          method_option :global, type: :boolean, default: false, desc: "Target global skills"
+          method_option :local, type: :boolean, default: false, desc: "Target local skills"
+          method_option :agent, type: :string, desc: "Target a specific agent (e.g. claude, codex)"
+          def skills(subcommand = nil, *args)
+            case subcommand
+            when nil, "list"
+              skills_list
+            when "enable"
+              name = args.first
+              unless name
+                ui.error("Usage: shai skills enable <name> [--global|--local] [--agent <agent>]")
+                exit EXIT_INVALID_INPUT
+              end
+              skills_enable(name)
+            when "disable"
+              name = args.first
+              unless name
+                ui.error("Usage: shai skills disable <name> [--global|--local] [--agent <agent>]")
+                exit EXIT_INVALID_INPUT
+              end
+              skills_disable(name)
+            else
+              ui.error("Unknown subcommand: #{subcommand}. Use `shai skills`, `shai skills enable`, or `shai skills disable`")
+              exit EXIT_INVALID_INPUT
+            end
+          end
+        end
+      end
+
+      private
+
+      def skills_list
+        scanner = SkillScanner.new
+        all_skills = scanner.scan_all
+        populate_sources!(all_skills)
+
+        if all_skills.empty?
+          ui.info("No skills found.")
+          ui.blank
+          ui.info("Skill discovery paths:")
+          SkillScanner::AGENTS.each do |agent|
+            ui.info("  Global: ~/#{agent[:skill_dir]}/*/SKILL.md (#{agent[:name]})")
+            ui.info("  Local:  ./#{agent[:skill_dir]}/*/SKILL.md (#{agent[:name]})")
+          end
+          return
+        end
+
+        global_skills = all_skills.select { |s| s.scope == :global }
+        local_skills = all_skills.select { |s| s.scope == :local }
+
+        if global_skills.any?
+          ui.blank
+          ui.header("Global skills")
+          ui.blank
+          ui.table(
+            ["Skill", "Status", "Agent", "Source"],
+            global_skills.map { |s| skill_row(s) }
+          )
+        end
+
+        if local_skills.any?
+          ui.blank
+          ui.header("Local skills")
+          ui.blank
+          ui.table(
+            ["Skill", "Status", "Agent", "Source"],
+            local_skills.map { |s| skill_row(s) }
+          )
+        end
+
+        enabled_count = all_skills.count(&:enabled)
+        disabled_count = all_skills.count { |s| !s.enabled }
+        ui.blank
+        ui.info("#{enabled_count} enabled, #{disabled_count} disabled")
+      end
+
+      def skills_enable(name)
+        scanner, skill = resolve_skill(scanner_instance, name)
+        return unless skill
+
+        if skill.enabled
+          ui.info("Skill '#{name}' is already enabled (#{skill.scope}, #{skill.agent})")
+          return
+        end
+
+        scanner.enable!(skill)
+        ui.success("Enabled skill '#{name}' (#{skill.scope}, #{skill.agent})")
+      end
+
+      def skills_disable(name)
+        scanner, skill = resolve_skill(scanner_instance, name)
+        return unless skill
+
+        unless skill.enabled
+          ui.info("Skill '#{name}' is already disabled (#{skill.scope}, #{skill.agent})")
+          return
+        end
+
+        scanner.disable!(skill)
+        ui.success("Disabled skill '#{name}' (#{skill.scope}, #{skill.agent})")
+      end
+
+      def scanner_instance
+        SkillScanner.new
+      end
+
+      def resolve_skill(scanner, name)
+        validate_scope_flags!
+        validate_agent_flag!
+
+        scope = if options[:global]
+          :global
+        elsif options[:local]
+          :local
+        end
+
+        agent = options[:agent]
+
+        matches = scanner.find(name, scope: scope, agent: agent)
+
+        if matches.empty?
+          ui.error("Skill '#{name}' not found. Run `shai skills` to see available skills.")
+          exit EXIT_NOT_FOUND
+        end
+
+        if matches.length > 1
+          ambiguous_by_scope = matches.map(&:scope).uniq.length > 1
+          ambiguous_by_agent = matches.map(&:agent).uniq.length > 1
+
+          ui.error("Skill '#{name}' exists in multiple #{ambiguous_by_agent ? "agents" : "scopes"}:")
+          matches.each { |s| ui.info("  - #{s.scope}, #{s.agent} (#{s.path})") }
+
+          hints = []
+          hints << "--global or --local" if ambiguous_by_scope
+          hints << "--agent <agent>" if ambiguous_by_agent
+          ui.info("Use #{hints.join(" and ")} to specify which one.")
+          exit EXIT_INVALID_INPUT
+        end
+
+        [scanner, matches.first]
+      end
+
+      def validate_scope_flags!
+        if options[:global] && options[:local]
+          ui.error("Cannot use --global and --local together")
+          exit EXIT_INVALID_INPUT
+        end
+      end
+
+      def validate_agent_flag!
+        agent = options[:agent]
+        return unless agent
+
+        known = SkillScanner::AGENTS.map { |a| a[:name] }
+        unless known.include?(agent)
+          ui.error("Unknown agent '#{agent}'. Known agents: #{known.join(", ")}")
+          exit EXIT_INVALID_INPUT
+        end
+      end
+
+      def skill_row(skill)
+        status = skill.enabled ? "enabled" : "disabled"
+        source = skill.source || "-"
+        [skill.name, status, skill.agent, source]
+      end
+
+      def populate_sources!(skills)
+        [Dir.home, Dir.pwd].each do |base|
+          installed = InstalledProjects.new(base)
+          next if installed.empty?
+
+          skills.each do |skill|
+            next if skill.source
+
+            installed.project_slugs.each do |slug|
+              files = installed.files_for_project(slug)
+              SkillScanner::AGENTS.each do |agent|
+                skill_relative = "#{agent[:skill_dir]}/#{skill.name}/SKILL.md"
+                if files.any? { |f| f == skill_relative || f.start_with?("#{agent[:skill_dir]}/#{skill.name}/") }
+                  skill.source = slug
+                  break
+                end
+              end
+              break if skill.source
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shai/install_registry.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "time"
+require "fileutils"
+
+module Shai
+  class InstallRegistry
+    def initialize
+      @file_path = File.join(Shai.configuration.config_dir, "installations.yml")
+      @data = load_data
+    end
+
+    attr_reader :file_path
+
+    def add(slug, path)
+      @data["projects"][slug] = {
+        "path" => File.expand_path(path),
+        "installed_at" => Time.now.iso8601
+      }
+      save!
+    end
+
+    def remove(slug)
+      removed = @data["projects"].delete(slug)
+      save! if removed
+      removed
+    end
+
+    def path_for(slug)
+      @data.dig("projects", slug, "path")
+    end
+
+    def all
+      @data["projects"].dup
+    end
+
+    def has?(slug)
+      @data["projects"].key?(slug)
+    end
+
+    private
+
+    def load_data
+      return default_data unless File.exist?(@file_path)
+
+      raw = YAML.safe_load_file(@file_path) || {}
+      (raw.is_a?(Hash) && raw["projects"].is_a?(Hash)) ? raw : default_data
+    rescue
+      default_data
+    end
+
+    def default_data
+      {"projects" => {}}
+    end
+
+    def save!
+      FileUtils.mkdir_p(File.dirname(@file_path))
+      File.write(@file_path, YAML.dump(@data))
+    end
+  end
+end

data/lib/shai/installed_projects.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "time"
+
+module Shai
+  class InstalledProjects
+    FILENAME = ".shai-installed"
+    CURRENT_VERSION = 2
+
+    attr_reader :base_path
+
+    def initialize(base_path)
+      @base_path = File.expand_path(base_path)
+      @data = load_data
+    end
+
+    def file_path
+      File.join(base_path, FILENAME)
+    end
+
+    def exists?
+      File.exist?(file_path)
+    end
+
+    def projects
+      @data["projects"] || {}
+    end
+
+    def project_slugs
+      projects.keys
+    end
+
+    def empty?
+      projects.empty?
+    end
+
+    def project_count
+      projects.size
+    end
+
+    def has_project?(slug)
+      projects.key?(slug)
+    end
+
+    def get_project(slug)
+      projects[slug]
+    end
+
+    def files_for_project(slug)
+      projects.dig(slug, "files") || []
+    end
+
+    def all_installed_files
+      projects.values.flat_map { |p| p["files"] || [] }
+    end
+
+    # Find which project owns a specific file
+    def project_for_file(file_path)
+      projects.each do |slug, data|
+        return slug if (data["files"] || []).include?(file_path)
+      end
+      nil
+    end
+
+    # Check for conflicts between new files and already installed projects
+    # Returns hash of { file_path => owning_project_slug }
+    def find_conflicts(new_files)
+      conflicts = {}
+      new_files.each do |file|
+        owner = project_for_file(file)
+        conflicts[file] = owner if owner
+      end
+      conflicts
+    end
+
+    # Add a new project with its files
+    def add_project(slug, files)
+      @data["projects"][slug] = {
+        "installed_at" => Time.now.iso8601,
+        "files" => files.sort
+      }
+      save!
+    end
+
+    # Remove a project and return its files
+    def remove_project(slug)
+      project = @data["projects"].delete(slug)
+      save! if project
+      project&.dig("files") || []
+    end
+
+    # Remove specific files from a project (when being overwritten)
+    def remove_files_from_project(slug, files_to_remove)
+      return unless @data["projects"][slug]
+
+      current_files = @data["projects"][slug]["files"] || []
+      @data["projects"][slug]["files"] = current_files - files_to_remove
+
+      # If no files left, remove the project entirely
+      if @data["projects"][slug]["files"].empty?
+        @data["projects"].delete(slug)
+      end
+
+      save!
+    end
+
+    def save!
+      content = YAML.dump(@data)
+      header = "# Installed by shai - do not edit manually\n"
+      File.write(file_path, header + content)
+    end
+
+    def delete!
+      File.delete(file_path) if exists?
+    end
+
+    private
+
+    def load_data
+      return default_data unless exists?
+
+      raw = YAML.safe_load_file(file_path) || {}
+
+      # Handle old format (version 1 / no version)
+      if raw["version"].nil? || raw["version"] < CURRENT_VERSION
+        migrate_from_v1(raw)
+      else
+        raw
+      end
+    rescue
+      # If file is corrupted, start fresh
+      default_data
+    end
+
+    def default_data
+      {
+        "version" => CURRENT_VERSION,
+        "projects" => {}
+      }
+    end
+
+    def migrate_from_v1(old_data)
+      # Old format had: { "slug" => "name", "installed_at" => "..." }
+      slug = old_data["slug"]
+      installed_at = old_data["installed_at"]
+
+      if slug
+        {
+          "version" => CURRENT_VERSION,
+          "projects" => {
+            slug => {
+              "installed_at" => installed_at || Time.now.iso8601,
+              "files" => [] # We don't know the files from v1, will be populated on next operation
+            }
+          }
+        }
+      else
+        default_data
+      end
+    end
+  end
+end

data/lib/shai/skill_scanner.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Shai
+  Skill = Struct.new(:name, :scope, :enabled, :path, :source, :agent, keyword_init: true)
+
+  class SkillScanner
+    SKILL_FILE = "SKILL.md"
+    DISABLED_SUFFIX = ".disabled"
+
+    AGENTS = [
+      {name: "claude", skill_dir: ".claude/skills"},
+      {name: "codex", skill_dir: ".agents/skills"}
+    ].freeze
+
+    attr_reader :local_base, :global_base
+
+    def initialize(local_base: Dir.pwd, global_base: Dir.home)
+      @local_base = File.expand_path(local_base)
+      @global_base = File.expand_path(global_base)
+    end
+
+    def scan_all
+      skills = []
+      skills.concat(scan_scope(:global))
+      skills.concat(scan_scope(:local))
+      skills
+    end
+
+    def find(name, scope: nil, agent: nil)
+      skills = scan_all
+      skills.select! { |s| s.name == name }
+      skills.select! { |s| s.scope == scope } if scope
+      skills.select! { |s| s.agent == agent } if agent
+      skills
+    end
+
+    def enable!(skill)
+      return false if skill.enabled
+      disabled_path = skill.path
+      enabled_path = disabled_path.sub(/#{Regexp.escape(DISABLED_SUFFIX)}$/o, "")
+      return false unless File.exist?(disabled_path)
+
+      File.rename(disabled_path, enabled_path)
+      true
+    end
+
+    def disable!(skill)
+      return false unless skill.enabled
+      enabled_path = skill.path
+      disabled_path = "#{enabled_path}#{DISABLED_SUFFIX}"
+      return false unless File.exist?(enabled_path)
+
+      File.rename(enabled_path, disabled_path)
+      true
+    end
+
+    private
+
+    def scan_scope(scope)
+      base = (scope == :global) ? global_base : local_base
+      skills = []
+
+      AGENTS.each do |agent|
+        skill_dir = File.join(base, agent[:skill_dir])
+        next unless Dir.exist?(skill_dir)
+
+        Dir.children(skill_dir).sort.each do |entry|
+          full_dir = File.join(skill_dir, entry)
+          next unless File.directory?(full_dir)
+
+          enabled_file = File.join(full_dir, SKILL_FILE)
+          disabled_file = File.join(full_dir, "#{SKILL_FILE}#{DISABLED_SUFFIX}")
+
+          if File.exist?(enabled_file)
+            skills << Skill.new(
+              name: entry,
+              scope: scope,
+              enabled: true,
+              path: enabled_file,
+              source: nil,
+              agent: agent[:name]
+            )
+          elsif File.exist?(disabled_file)
+            skills << Skill.new(
+              name: entry,
+              scope: scope,
+              enabled: false,
+              path: disabled_file,
+              source: nil,
+              agent: agent[:name]
+            )
+          end
+        end
+      end
+
+      skills
+    end
+  end
+end

data/lib/shai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Shai
-  VERSION = "0.1.1"
+  VERSION = "0.3.0"
 end

data/lib/shai.rb

@@ -4,6 +4,9 @@ require_relative "shai/version"
 require_relative "shai/configuration"
 require_relative "shai/credentials"
 require_relative "shai/api_client"
+require_relative "shai/installed_projects"
+require_relative "shai/install_registry"
+require_relative "shai/skill_scanner"
 require_relative "shai/cli"
 
 module Shai
@@ -19,6 +22,41 @@ module Shai
 
   class InvalidConfigurationError < Error; end
 
+  class RateLimitError < Error
+    attr_reader :retry_after
+
+    def initialize(message = "Too many requests", retry_after: nil)
+      @retry_after = retry_after
+      super(message)
+    end
+  end
+
+  class DeviceFlowError < Error
+    attr_reader :error_code, :interval
+
+    def initialize(error_code, interval: nil)
+      @error_code = error_code
+      @interval = interval
+      super(error_code)
+    end
+
+    def authorization_pending?
+      error_code == "authorization_pending"
+    end
+
+    def slow_down?
+      error_code == "slow_down"
+    end
+
+    def access_denied?
+      error_code == "access_denied"
+    end
+
+    def expired?
+      error_code == "expired_token"
+    end
+  end
+
   # Exit codes as specified in tech spec
   EXIT_SUCCESS = 0
   EXIT_GENERAL_ERROR = 1

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shai-cli
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Sebastian Jimenez
@@ -107,6 +107,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: launchy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
 description: A command-line interface for shaicli.dev - download, share, and sync
   AI agent configurations (Claude, Cursor, etc.) across projects and teams.
 email:
@@ -125,9 +139,13 @@ files:
 - lib/shai/commands/auth.rb
 - lib/shai/commands/config.rb
 - lib/shai/commands/configurations.rb
+- lib/shai/commands/skills.rb
 - lib/shai/commands/sync.rb
 - lib/shai/configuration.rb
 - lib/shai/credentials.rb
+- lib/shai/install_registry.rb
+- lib/shai/installed_projects.rb
+- lib/shai/skill_scanner.rb
 - lib/shai/ui.rb
 - lib/shai/version.rb
 homepage: https://shaicli.dev
@@ -152,7 +170,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: CLI tool for managing shared AI agent configurations
 test_files: []