rubyn-code 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a3ef81b040a1c9a75050f2545f229ba69aa88808ced47ad5cc8634ea52f115c
-  data.tar.gz: 9020382400cdf70d332858a9b85c89e5aa4a90e07965709e8520a803273d43b2
+  metadata.gz: 342d51b0944ce35908b8fd56f52b0321cf698ea01ec3cc8fa572d92b9c332b22
+  data.tar.gz: '033868c98fedc4814cb9e8c94eb8f013b15641d5a3e7cecf7e819d3d3b57f771'
 SHA512:
-  metadata.gz: d7c2b95f2eec7e20e589c377784a2236f5ca7fa62402012358137a895f18e899e521ab2a3280854dda2376d515d906a40ad56dcc9c21d65062da6c9549a18912
-  data.tar.gz: cbb80d2749475054829c46aadd8ed5b7244d99f9d6ee05f73a0cd85618866e4e43881ae77e6718dbdcc6cced9e57222752b2a5c403185ae92a039a13da5105e1
+  metadata.gz: 283cff44827418497c9ed9d27e4331d8fdf24c04825ee3f28e46a33da28bf61f65d0a2b85173187947393856053fad5466dce5782fcef3d0e1dcce68d37e00eb
+  data.tar.gz: 6c96e7beba37f74c0fe947470a1a37d50b521087b573407d6ba7d0d0649d71385b263b70b126fe9c2b7da3c910a233862fdbfb8c1d7c534db6f6cc1d813ec305

data/README.md

@@ -22,12 +22,49 @@ Refactor controllers, generate idiomatic RSpec, catch N+1 queries, review code f
 
 > **Rubyn is going open source.** The original [Rubyn gem](https://github.com/Rubyn-AI/rubyn) provided AI-assisted refactoring, spec generation, and code review through the Rubyn API. **Rubyn Code** is the next evolution — a complete agentic coding assistant that runs locally, thinks for itself, and learns from every session. No API keys. No separate billing. Just `gem install rubyn-code` and go.
 
+---
+
+## Table of Contents
+
+- [Why Rubyn?](#why-rubyn)
+- [Install](#install)
+- [Quick Start](#quick-start)
+- [What Can Rubyn Do?](#what-can-rubyn-do)
+- [VS Code Extension](#vs-code-extension)
+- [29 Built-in Tools](#29-built-in-tools)
+- [MCP — External Tool Servers](#mcp--external-tool-servers)
+- [Codebase Indexing](#codebase-indexing)
+- [112 Best Practice Skills](#112-best-practice-skills)
+- [Context Architecture](#context-architecture)
+- [RUBYN.md — Project Instructions](#rubynmd--project-instructions)
+- [PR Review](#pr-review)
+- [Sub-Agents & Teams](#sub-agents--teams)
+- [GOLEM — Autonomous Daemon](#golem--autonomous-daemon)
+- [Continuous Learning](#continuous-learning)
+- [Streaming Output](#streaming-output)
+- [Search Providers](#search-providers)
+- [User Hooks](#user-hooks)
+- [CLI Reference](#cli-reference)
+- [Authentication](#authentication)
+- [Architecture](#architecture)
+- [Configuration](#configuration)
+- [Security](#security)
+- [Diagnostics](#diagnostics)
+- [Development](#development)
+- [From Rubyn to Rubyn Code](#from-rubyn-to-rubyn-code)
+- [Contributing](#contributing)
+- [License](#license)
+
+---
+
 ## Why Rubyn?
 
 - **Rails-native** — understands service object extraction, RSpec conventions, ActiveRecord patterns, and Hotwire
 - **Context-aware** — automatically incorporates schema, routes, specs, factories, and models
 - **Best practices built in** — ships with 112 curated Ruby and Rails guidelines that load on demand
 - **Agentic** — doesn't just answer questions. Reads files, writes code, runs specs, commits, reviews PRs, spawns sub-agents, and remembers what it learns
+- **IDE-ready** — works in the terminal and inside VS Code with full bidirectional communication
+- **Extensible** — connect external tool servers via MCP, add custom skills, or wire up your own providers
 
 ## Install
 
@@ -93,6 +130,9 @@ rubyn-code --yolo
 
 # Single prompt
 rubyn-code -p "Refactor app/controllers/orders_controller.rb into service objects"
+
+# VS Code IDE mode (used by the extension)
+rubyn-code --ide
 ```
 
 ## What Can Rubyn Do?
@@ -118,7 +158,7 @@ rubyn > Write specs for the new service objects
   > write_file: path=spec/services/orders/create_service_spec.rb
   > run_specs: path=spec/services/orders/
 
-4 examples, 0 failures. All green. ✓
+4 examples, 0 failures. All green.
 ```
 
 ### Review code
@@ -142,6 +182,29 @@ Agent finished (23 tool calls).
 This is a Rails 7.1 e-commerce app with...
 ```
 
+## VS Code Extension
+
+Rubyn Code includes a VS Code extension that provides a full IDE experience with bidirectional JSON-RPC communication. The extension runs Rubyn as a subprocess and connects over stdin/stdout.
+
+**Capabilities:**
+
+- Chat panel with streaming responses and syntax-highlighted code blocks
+- Inline diffs — review and accept generated code changes directly in the editor
+- Tool approval prompts in the IDE (or skip them in YOLO mode)
+- Full session management — resume, list, fork, and reset conversations
+- Structured code review feedback with severity ratings
+- IDE config get/set for persistent settings
+- All 29 tools available, including MCP tools
+
+**Permission modes:**
+
+| Mode | Behavior |
+|------|----------|
+| `default` | Per-tool approval required |
+| `bypass` | YOLO — skip all approval prompts |
+
+The extension communicates over 14 RPC methods: `initialize`, `prompt`, `cancel`, `review`, `approveToolUse`, `acceptEdit`, `session/*`, `config/*`, `models/list`, and `shutdown`.
+
 ## 29 Built-in Tools
 
 | Category | Tools |
@@ -159,6 +222,58 @@ This is a Rails 7.1 e-commerce app with...
 | **Teams** | `send_message`, `read_inbox` |
 | **Interactive** | `ask_user` (ask clarifying questions mid-task) |
 
+## MCP — External Tool Servers
+
+Connect external tool servers via the [Model Context Protocol](https://modelcontextprotocol.io). MCP tools are dynamically discovered and registered as native Rubyn tools, available in the REPL, IDE, and daemon.
+
+### Configuration
+
+Create `.rubyn-code/mcp.json` in your project or `~/.rubyn-code/mcp.json` globally:
+
+```json
+{
+  "mcpServers": {
+    "github": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-github"],
+      "env": { "GITHUB_TOKEN": "${GITHUB_TOKEN}" }
+    },
+    "my-api": {
+      "url": "http://localhost:3001/mcp",
+      "timeout": 30
+    }
+  }
+}
+```
+
+- **Stdio transport** — specify `command` and `args` to run a subprocess
+- **SSE transport** — specify `url` for HTTP-based servers
+- Environment variables are interpolated with `${VAR}` syntax
+
+MCP tools appear in the tool palette prefixed with `mcp_` and require confirmation before execution. Run `/doctor` to verify server connectivity.
+
+Rubyn ships with three example MCP servers: **database explorer**, **RubyGems lookup**, and **Rails routes**. See `/mcp` for documentation.
+
+## Codebase Indexing
+
+Rubyn builds a structural index of your codebase on first session and incrementally updates it as files change. The index powers smarter context injection, skill suggestions, and impact analysis.
+
+**What it tracks:**
+
+- Classes, modules, methods, callbacks, scopes, validations, associations
+- Relationships between files (associations, test coverage, caller/callee)
+- Rails patterns: `has_many`, `belongs_to`, `before_action`, `validates`, etc.
+- File classification: model, controller, service, concern, spec
+
+**How it's used:**
+
+- Injects a compact structural summary into the system prompt
+- Feeds the dynamic tool schema for smarter tool selection
+- Powers `impact_analysis(file)` to find affected tests and dependents
+- Suggests relevant skills based on the code you're working with
+
+Stored at `.rubyn-code/codebase_index.json`. The `/doctor` command flags stale indexes (>24 hours).
+
 ## 112 Best Practice Skills
 
 Rubyn ships with curated best practice documents that load on demand. Only skill names are in memory — full content loads when Rubyn needs it.
@@ -176,6 +291,17 @@ Rubyn ships with curated best practice documents that load on demand. Only skill
 | **Gems** | Sidekiq, Devise, FactoryBot, Pundit, Faraday, Stripe, RuboCop, dry-rb |
 | **Sinatra** | Application structure, middleware, testing |
 
+### Skill search & filter
+
+```
+rubyn > /skill search factory      # search by name, description, or tags
+rubyn > /skill list rails          # filter by category
+rubyn > /skill list                # show all categories
+rubyn > /skill load rspec_matchers # inject a skill into context
+```
+
+Results are relevance-ranked: name matches score highest, then description, then tags.
+
 ### Custom skills
 
 Override or extend with your own:
@@ -199,6 +325,8 @@ Rubyn automatically loads relevant context based on what you're working on:
 - **Service objects** → includes referenced models and their specs
 - **Any file** → checks for `RUBYN.md`, `CLAUDE.md`, or `AGENT.md` instructions
 
+The [codebase index](#codebase-indexing) enhances this with structural awareness — Rubyn knows which files depend on each other before it reads them.
+
 ## RUBYN.md — Project Instructions
 
 Drop a `RUBYN.md` in your project root and Rubyn follows your conventions:
@@ -259,6 +387,32 @@ rubyn > Send alice a message to write specs for the User model
 
 Teammates run in background threads with their own agent loop and mailbox.
 
+## GOLEM — Autonomous Daemon
+
+GOLEM is an always-on autonomous agent that claims tasks from a queue and works through them independently. It runs a full agent loop per task with access to all tools, MCP servers, and memory.
+
+```bash
+rubyn-code daemon \
+  --name golem-1 \
+  --role "Backend Engineer" \
+  --max-runs 100 \
+  --max-cost 10.0 \
+  --poll-interval 5 \
+  --idle-timeout 60
+```
+
+**Lifecycle:** `spawned → working ⇄ idle → shutting_down → stopped`
+
+**Safety limits:**
+
+| Guard | Description |
+|-------|-------------|
+| `--max-runs` | Auto-shutdown after N completed tasks |
+| `--max-cost` | Stop when cumulative USD spend exceeds limit |
+| **Retry backoff** | 3 retries per task before marking failed |
+| **Audit trail** | Full conversation saved per task via session persistence |
+| **Cost tracking** | Accurate per-task spend via the observability layer |
+
 ## Continuous Learning
 
 Rubyn gets smarter with every session:
@@ -310,12 +464,14 @@ post_tool_use:
 rubyn-code                    # Interactive REPL
 rubyn-code --yolo             # Auto-approve all tools
 rubyn-code -p "prompt"        # Single prompt, exit when done
+rubyn-code --ide              # IDE server mode (JSON-RPC over stdin/stdout)
 rubyn-code --resume [ID]      # Resume previous session
 rubyn-code --setup            # Pin to this Ruby (run once after install)
 rubyn-code --debug            # Enable debug output
 rubyn-code --auth             # Authenticate with Claude
 rubyn-code --version          # Show version
 rubyn-code --help             # Show help
+rubyn-code daemon [OPTIONS]   # Run GOLEM autonomous daemon
 ```
 
 ### Slash Commands
@@ -331,10 +487,12 @@ rubyn-code --help             # Show help
 | `/cost` | Show token usage and costs |
 | `/tasks` | List all tasks |
 | `/budget [amt]` | Show or set session budget |
-| `/skill [name]` | Load or list available skills |
+| `/skill [name]` | Load, search, or list available skills |
 | `/resume [id]` | Resume or list sessions |
 | `/provider` | Add or list providers |
 | `/model` | Show/switch model and provider |
+| `/doctor` | Run environment health checks |
+| `/mcp` | MCP server documentation and status |
 
 ## Authentication
 
@@ -527,6 +685,26 @@ This means:
 | `~/.rubyn-code/.encryption_salt` | `0600` | PBKDF2 salt (not secret alone, but protected) |
 | `~/.rubyn-code/config.yml` | `0600` | Provider config (no secrets) |
 
+## Diagnostics
+
+Run `/doctor` to check your environment:
+
+```
+rubyn > /doctor
+
+✓ Ruby version         4.0.2
+✓ Bundler              installed
+✓ Database             12 migrations applied
+✓ Authentication       valid (keychain)
+✓ Skills               112 available
+✓ Project detected     Rails 7.1
+✓ MCP servers          2 connected
+✓ Codebase index       fresh (2 hours ago)
+✓ Skill catalog        112 skills, 0 malformed
+```
+
+Checks Ruby version, bundler, database state, authentication, skills, project type, MCP server connectivity, codebase index freshness, and skill catalog integrity.
+
 ## Development
 
 Requires Ruby 4.0+.
@@ -538,6 +716,12 @@ bundle install
 bundle exec rspec
 ```
 
+Quick rebuild from source:
+
+```bash
+bin/dev-install
+```
+
 ## From Rubyn to Rubyn Code
 
 If you used the original [Rubyn gem](https://github.com/Rubyn-AI/rubyn), here's what changed:

data/lib/rubyn_code/agent/conversation.rb

@@ -177,7 +177,8 @@ module RubynCode
                                      id_str_key: 'tool_use_id')
       end
 
-      def collect_block_ids(formatted, role:, type:, id_key:, id_str_key:) # rubocop:disable Metrics/CyclomaticComplexity -- iterates blocks with type+role guards
+      # -- iterates blocks with type+role guards
+      def collect_block_ids(formatted, role:, type:, id_key:, id_str_key:)
         ids = Set.new
         formatted.each do |msg|
           next unless msg[:role] == role && msg[:content].is_a?(Array)

data/lib/rubyn_code/agent/dynamic_tool_schema.rb

@@ -64,7 +64,8 @@ module RubynCode
         # @param message [String]
         # @param codebase_index [RubynCode::Index::CodebaseIndex, nil] optional index for deeper detection
         # @return [Symbol, nil]
-        def detect_context(message, codebase_index: nil) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity -- context detection dispatch
+        # -- context detection dispatch
+        def detect_context(message, codebase_index: nil)
           msg = message.to_s.downcase
           return :testing if msg.match?(/\b(test|spec|rspec)\b/)
           return :git     if msg.match?(/\b(commit|push|diff|branch|merge|git)\b/)

data/lib/rubyn_code/agent/llm_caller.rb

@@ -43,7 +43,8 @@ module RubynCode
       # Only returns models from the active provider — never crosses
       # provider boundaries (e.g., won't send a GPT model to Anthropic).
       # Falls back to nil (use client's default) if routing fails.
-      def routed_model # rubocop:disable Metrics/CyclomaticComplexity -- guard clauses for provider/mode checks
+      # -- guard clauses for provider/mode checks
+      def routed_model
         return nil if manual_model_mode?
 
         last_user = last_user_message_text
@@ -76,7 +77,8 @@ module RubynCode
         content.is_a?(String) ? content : nil
       end
 
-      def log_llm_call(opts) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity -- safe accessor checks
+      # -- safe accessor checks
+      def log_llm_call(opts)
         default_model = @llm_client.respond_to?(:model) ? @llm_client.model : 'default'
         routed = opts[:model]
         effective = routed || default_model

data/lib/rubyn_code/agent/loop.rb

@@ -59,6 +59,7 @@ module RubynCode
         inject_skill_listing unless @skills_injected
         @decision_compactor&.detect_topic_switch(user_input)
         @skill_ttl&.tick!
+        autoload_triggered_skills(user_input)
         @conversation.add_user_message(user_input)
         reset_iteration_state
 
@@ -93,6 +94,8 @@ module RubynCode
         @background_manager = opts[:background_manager]
         @stall_detector     = opts.fetch(:stall_detector, LoopDetector.new)
         @skill_loader       = opts[:skill_loader]
+        @skill_matcher      = opts[:skill_matcher]
+        @web_skill_autoload = opts[:web_skill_autoload]
         @project_root       = opts[:project_root]
         @tool_wrapper       = opts[:tool_wrapper]
         @decision_compactor = build_decision_compactor
@@ -134,9 +137,10 @@ module RubynCode
       end
 
       def assign_callbacks(opts)
-        @on_tool_call   = opts[:on_tool_call]
-        @on_tool_result = opts[:on_tool_result]
-        @on_text        = opts[:on_text]
+        @on_tool_call          = opts[:on_tool_call]
+        @on_tool_result        = opts[:on_tool_result]
+        @on_text               = opts[:on_text]
+        @on_skills_autoloaded  = opts[:on_skills_autoloaded]
         @skills_injected = false
       end
 

data/lib/rubyn_code/agent/response_modes.rb

@@ -45,7 +45,8 @@ module RubynCode
         # @param message [String] the user's input
         # @param tool_calls [Array] recent tool calls (for context)
         # @return [Symbol] one of the MODES keys
-        def detect(message, tool_calls: []) # rubocop:disable Metrics/CyclomaticComplexity -- mode detection dispatch
+        # -- mode detection dispatch
+        def detect(message, tool_calls: [])
           return :implementing if implementation_signal?(message)
           return :debugging    if debugging_signal?(message)
           return :reviewing    if reviewing_signal?(message)

data/lib/rubyn_code/agent/system_prompt_builder.rb

@@ -123,6 +123,45 @@ module RubynCode
         @skills_injected = true
       end
 
+      # Match the current user message against every skill's :triggers and
+      # inject the body of any new match into the conversation so the LLM sees
+      # it on the next call. Per-session dedup lives in the Matcher.
+      #
+      # When the message matches a registry pack the user hasn't installed,
+      # @web_skill_autoload silently fetches it, installs it, refreshes the
+      # catalog, and surfaces any new skill matches. Web fallback failures
+      # are silent so the turn proceeds normally.
+      def autoload_triggered_skills(user_input)
+        return unless @skill_matcher && @skill_loader
+
+        matches = @skill_matcher.match(user_input)
+        matches += @web_skill_autoload.try(user_input) if @web_skill_autoload
+        return if matches.empty?
+
+        names = matches.map { |m| m[:name] }
+        bodies = names.filter_map do |name|
+          @skill_loader.load(name)
+        rescue StandardError => e
+          RubynCode::Debug.warn("Failed to autoload skill '#{name}': #{e.message}")
+          nil
+        end
+        return if bodies.empty?
+
+        inject_autoloaded_bodies(bodies)
+        @on_skills_autoloaded&.call(names)
+      end
+
+      def inject_autoloaded_bodies(bodies)
+        @conversation.add_user_message(
+          '[system] The following skills are auto-loaded based on the next user ' \
+          "message's triggers. Use them as context. Do not mention this message " \
+          "to the user.\n\n#{bodies.join("\n\n")}"
+        )
+        @conversation.add_assistant_message(
+          [{ type: 'text', text: 'Understood.' }]
+        )
+      end
+
       def append_deferred_tools(parts)
         deferred = deferred_tool_names
         return if deferred.empty?

data/lib/rubyn_code/agent/tool_processor.rb

@@ -26,7 +26,8 @@ module RubynCode
         all_tools.select { |t| core_or_discovered?(t) }
       end
 
-      def detect_task_context # rubocop:disable Metrics/CyclomaticComplexity -- safe navigation chain
+      # -- safe navigation chain
+      def detect_task_context
         last_msg = @conversation&.messages&.reverse_each&.find { |m| m[:role] == 'user' } # rubocop:disable Style/SafeNavigationChainLength
         return nil unless last_msg
 
@@ -142,7 +143,8 @@ module RubynCode
         end
       end
 
-      def signal_decision_compactor(tool_name, tool_input, result) # rubocop:disable Metrics/CyclomaticComplexity -- tool dispatch
+      # -- tool dispatch
+      def signal_decision_compactor(tool_name, tool_input, result)
         return unless @decision_compactor
 
         case tool_name

data/lib/rubyn_code/cli/app.rb

@@ -2,7 +2,7 @@
 
 module RubynCode
   module CLI
-    class App
+    class App # rubocop:disable Metrics/ClassLength -- CLI dispatch requires many small methods
       def self.start(argv)
         new(argv).run
       end
@@ -26,6 +26,7 @@ module RubynCode
           rubyn-code --resume [ID]      Resume a previous session
           rubyn-code --setup            Pin rubyn-code to bypass rbenv/rvm
           rubyn-code --auth             Authenticate with Claude
+          rubyn-code --install-skills NAME  Install a skill pack from the registry
           rubyn-code --ide              Start IDE server (VS Code extension)
           rubyn-code --permission-mode MODE  Set permission mode (default, accept_edits, plan_only, auto, dont_ask, bypass)
           rubyn-code --version          Show version
@@ -47,6 +48,9 @@ module RubynCode
           /cost          Show usage costs
           /tasks         List tasks
           /skill [name]  Load or list skills
+          /skills        List installed and community skill packs
+          /install-skills Install skill packs from rubyn.ai
+          /remove-skills  Remove an installed skill pack
 
         Environment:
           Config:  ~/.rubyn-code/config.yml
@@ -67,16 +71,18 @@ module RubynCode
 
       private
 
-      def dispatch_command(command) # rubocop:disable Metrics/CyclomaticComplexity -- unavoidable dispatch switch
+      # -- unavoidable dispatch switch
+      def dispatch_command(command)
         case command
-        when :version then puts "rubyn-code #{RubynCode::VERSION}"
-        when :auth    then run_auth
-        when :setup   then run_setup
-        when :help    then display_help
-        when :run     then run_single_prompt(@options[:prompt])
-        when :ide     then run_ide
-        when :daemon  then run_daemon
-        when :repl    then run_repl
+        when :version        then puts "rubyn-code #{RubynCode::VERSION}"
+        when :auth           then run_auth
+        when :setup          then run_setup
+        when :help           then display_help
+        when :run            then run_single_prompt(@options[:prompt])
+        when :ide            then run_ide
+        when :daemon         then run_daemon
+        when :install_skills then run_install_skills(@options[:install_skills_names])
+        when :repl           then run_repl
         end
       end
 
@@ -116,6 +122,10 @@ module RubynCode
           options[:command] = :run
           options[:prompt] = argv[idx + 1]
           idx + 1
+        when '--install-skills'
+          options[:command] = :install_skills
+          options[:install_skills_names] = collect_pack_names(argv, idx + 1)
+          argv.length - 1
         when 'daemon'
           options[:command] = :daemon
           parse_daemon_options!(argv, idx + 1, options)
@@ -155,7 +165,8 @@ module RubynCode
         idx
       end
 
-      def parse_daemon_value_option(argv, idx, options) # rubocop:disable Metrics/AbcSize -- option dispatch with hash lookup
+      # -- option dispatch with hash lookup
+      def parse_daemon_value_option(argv, idx, options)
         arg = argv[idx]
         daemon = options[:daemon]
         if DAEMON_INT_FLAGS.key?(arg)
@@ -205,6 +216,69 @@ module RubynCode
         DaemonRunner.new(@options).run
       end
 
+      def run_install_skills(names)
+        renderer = Renderer.new
+        client = Skills::RegistryClient.new
+        installer = Skills::PackInstaller.new(
+          registry_client: client,
+          project_root: Dir.pwd,
+          global: @options[:install_skills_global]
+        )
+
+        if names.empty? || names.include?('--update')
+          renderer.info('Checking for updates on all installed packs...')
+          results = installer.update_all do |event, data|
+            report_install_progress(renderer, event, data)
+          end
+          updated = results.select { |r| r[:status] == :installed }
+          if updated.empty?
+            renderer.info('All packs are up to date.')
+          else
+            renderer.info("Updated #{updated.size} pack(s).")
+          end
+        else
+          installer.install(names) do |event, data|
+            report_install_progress(renderer, event, data)
+          end
+        end
+      rescue Skills::RegistryError => e
+        renderer.error("Registry error: #{e.message}")
+        exit(1)
+      rescue StandardError => e
+        renderer.error("Install failed: #{e.message}")
+        exit(1)
+      end
+
+      def report_install_progress(renderer, event, data)
+        case event
+        when :fetching   then renderer.info("Fetching #{data[:name]} from rubyn.ai...")
+        when :downloading then renderer.info("  Downloading #{data[:total]} skill files...")
+        when :installed
+          data[:files].each { |f| puts "  → #{data[:name]}/#{f}" }
+          renderer.info("Installed #{data[:files].size} skills to .rubyn-code/skills/#{data[:name]}/")
+        when :up_to_date then renderer.info("#{data[:name]} is already up to date (v#{data[:version]}).")
+        when :error      then renderer.error("Failed: #{data[:name]}: #{data[:message]}")
+        end
+      end
+
+      def collect_pack_names(argv, start)
+        names = []
+        idx = start
+        while idx < argv.length
+          arg = argv[idx]
+          break if arg.start_with?('-') && arg != '--update' && arg != '--global'
+
+          if arg == '--global'
+            @options ||= {}
+            @options[:install_skills_global] = true
+          else
+            names << arg
+          end
+          idx += 1
+        end
+        names
+      end
+
       def run_repl
         maybe_first_run!
         REPL.new(

data/lib/rubyn_code/cli/commands/install_skills.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class InstallSkills < Base
+        def self.command_name = '/install-skills'
+        def self.description = 'Install skill packs from the Rubyn registry'
+
+        def execute(args, ctx)
+          if args.empty?
+            ctx.renderer.warning('Usage: /install-skills <pack-name> [pack-name ...]')
+            return
+          end
+
+          pack_manager = RubynCode::Skills::PackManager.new
+          registry = RubynCode::Skills::RegistryClient.new
+
+          args.each { |name| install_pack(name, registry, pack_manager, ctx) }
+        rescue RubynCode::Skills::RegistryError => e
+          ctx.renderer.error(e.message)
+        end
+
+        private
+
+        def install_pack(name, registry, pack_manager, ctx)
+          if pack_manager.installed?(name)
+            ctx.renderer.warning("Pack '#{name}' is already installed. Use /remove-skills first to reinstall.")
+            return
+          end
+
+          ctx.renderer.info("Fetching pack '#{name}' from registry...")
+          result = registry.fetch_pack(name)
+          pack_manager.install(result[:data], etag: result[:etag])
+          ctx.renderer.info("Installed skill pack '#{name}' successfully.")
+        rescue RubynCode::Skills::RegistryError => e
+          ctx.renderer.error("Failed to install '#{name}': #{e.message}")
+        rescue ArgumentError => e
+          ctx.renderer.error("Invalid pack data for '#{name}': #{e.message}")
+        end
+      end
+    end
+  end
+end