rubyn-code 0.3.0 → 0.5.0

data/lib/rubyn_code/tools/edit_file.rb

@@ -22,6 +22,12 @@ module RubynCode
       RISK_LEVEL = :write
       REQUIRES_CONFIRMATION = false
 
+      # Take the first line of the tool's output, which is already formatted
+      # as "Edited /path.rb (N replacements)".
+      def self.summarize(output, _args)
+        output.to_s.lines.first.to_s.chomp[0, 200]
+      end
+
       def execute(path:, old_text:, new_text:, replace_all: false)
         resolved = read_file_safely(path)
         content = File.read(resolved)
@@ -34,12 +40,34 @@ module RubynCode
         format_diff_result(path, content, old_text, new_text, replace_all)
       end
 
+      # Compute the proposed file content without writing to disk.
+      # Used by IDE mode to preview the edit in a diff view before the user
+      # accepts. Raises if old_text is missing or ambiguous, same as execute.
+      #
+      # @return [Hash] { content: String, type: 'modify' }
+      def preview_content(path:, old_text:, new_text:, replace_all: false)
+        resolved = read_file_safely(path)
+        content = File.read(resolved)
+
+        validate_occurrences!(path, content, old_text, replace_all)
+
+        { content: apply_replacement(content, old_text, new_text, replace_all), type: 'modify' }
+      end
+
       private
 
       def validate_occurrences!(path, content, old_text, replace_all)
         count = content.scan(old_text).length
 
-        raise Error, "old_text not found in #{path}. No changes made." if count.zero?
+        # If exact match fails, try with normalized trailing whitespace on
+        # each line. Models sometimes strip or add trailing spaces/tabs.
+        if count.zero?
+          normalized_content = normalize_trailing_ws(content)
+          normalized_old = normalize_trailing_ws(old_text)
+          count = normalized_content.scan(normalized_old).length
+
+          raise Error, "old_text not found in #{path}. No changes made." if count.zero?
+        end
 
         return if replace_all || count == 1
 
@@ -49,7 +77,28 @@ module RubynCode
       end
 
       def apply_replacement(content, old_text, new_text, replace_all)
-        replace_all ? content.gsub(old_text, new_text) : content.sub(old_text, new_text)
+        # Try exact match first
+        if content.include?(old_text)
+          return replace_all ? content.gsub(old_text, new_text) : content.sub(old_text, new_text)
+        end
+
+        # Fall back to normalized trailing-whitespace match
+        normalized_content = normalize_trailing_ws(content)
+        normalized_old = normalize_trailing_ws(old_text)
+
+        if normalized_content.include?(normalized_old)
+          if replace_all
+            normalized_content.gsub(normalized_old, new_text)
+          else
+            normalized_content.sub(normalized_old, new_text)
+          end
+        else
+          content.sub(old_text, new_text)
+        end
+      end
+
+      def normalize_trailing_ws(str)
+        str.gsub(/[^\S\n]+$/, '')
       end
 
       CONTEXT_LINES = 3 # rubocop:disable Lint/UselessConstantScoping
@@ -76,7 +125,7 @@ module RubynCode
       end
 
       def context_before(content, text)
-        idx = content.index(text)
+        idx = find_index(content, text)
         return [] unless idx
 
         before = content[0...idx].lines.last(CONTEXT_LINES)
@@ -84,7 +133,7 @@ module RubynCode
       end
 
       def context_after(content, text)
-        idx = content.index(text)
+        idx = find_index(content, text)
         return [] unless idx
 
         after_start = idx + text.length
@@ -93,11 +142,19 @@ module RubynCode
       end
 
       def find_line_number(content, text)
-        idx = content.index(text)
+        idx = find_index(content, text)
         return nil unless idx
 
         content[0...idx].count("\n") + 1
       end
+
+      # Find the index of text in content, falling back to normalized match.
+      def find_index(content, text)
+        idx = content.index(text)
+        return idx if idx
+
+        normalize_trailing_ws(content).index(normalize_trailing_ws(text))
+      end
     end
 
     Registry.register(EditFile)

data/lib/rubyn_code/tools/executor.rb

@@ -4,17 +4,20 @@ module RubynCode
   module Tools
     class Executor
       attr_reader :project_root, :output_compressor, :file_cache
-      attr_accessor :llm_client, :background_worker, :on_agent_status, :db, :ask_user_callback
+      attr_accessor :llm_client, :background_worker, :on_agent_status, :db, :ask_user_callback,
+                    :codebase_index, :ide_client
 
-      def initialize(project_root:)
+      def initialize(project_root:, ide_client: nil)
         @project_root = File.expand_path(project_root)
+        @ide_client = ide_client
         @injections = {}
         @output_compressor = OutputCompressor.new
         @file_cache = FileCache.new
         Registry.load_all!
       end
 
-      def execute(tool_name, params) # rubocop:disable Metrics/AbcSize -- maps tool errors to results
+      # -- maps tool errors to results
+      def execute(tool_name, params)
         # File cache intercept: serve cached reads, invalidate on writes
         cached = try_file_cache(tool_name, params)
         return cached if cached
@@ -23,6 +26,7 @@ module RubynCode
         filtered = filter_params(tool, params)
         raw = tool.truncate(tool.execute(**filtered).to_s)
         update_file_cache(tool_name, filtered, raw)
+        maybe_update_codebase_index(tool_name, filtered)
         @output_compressor.compress(tool_name, raw)
       rescue ToolNotFoundError => e
         error_result("Tool error: #{e.message}")
@@ -40,11 +44,24 @@ module RubynCode
         Registry.tool_definitions
       end
 
+      # Patterns that indicate a bash command writes to a file.
+      BASH_WRITE_PATTERNS = [
+        /(?:>>?)\s*(\S+)/,            # > file  or  >> file
+        /\btee\s+(?:-a\s+)?(\S+)/,    # tee file  or  tee -a file
+        /\bsed\s+-i\S*\s+.*\s(\S+)$/, # sed -i 's/...' file
+        /\bsed\s+-i\S*\s+.*\s(\S+)\s/ # sed -i 's/...' file (mid-command)
+      ].freeze
+
       private
 
       def build_tool(tool_name)
         tool_class = Registry.get(tool_name)
-        tool = tool_class.new(project_root: project_root)
+        # IDE-aware tools accept an ide_client parameter.
+        if @ide_client && tool_class.method(:new).parameters.any? { |_, name| name == :ide_client }
+          tool = tool_class.new(project_root: project_root, ide_client: @ide_client)
+        else
+          tool = tool_class.new(project_root: project_root)
+        end
         inject_dependencies(tool, tool_name)
         tool
       end
@@ -57,7 +74,8 @@ module RubynCode
         allowed.empty? ? symbolized : symbolized.slice(*allowed)
       end
 
-      def inject_dependencies(tool, tool_name) # rubocop:disable Metrics/CyclomaticComplexity -- tool-specific dependency injection
+      # -- tool-specific dependency injection
+      def inject_dependencies(tool, tool_name)
         case tool_name
         when 'spawn_agent', 'spawn_teammate'
           inject_agent_deps(tool)
@@ -88,13 +106,17 @@ module RubynCode
       end
 
       # Cache read_file results; invalidate on write_file/edit_file.
+      # Also detects bash commands that write to files (redirect, sed -i, tee).
       def update_file_cache(tool_name, params, _raw)
         path = resolve_cache_path(params)
-        return unless path
 
         case tool_name
-        when 'read_file' then @file_cache.read(path) # populates cache
-        when 'write_file', 'edit_file' then @file_cache.on_write(path)
+        when 'read_file'
+          @file_cache.read(path) if path # populates cache
+        when 'write_file', 'edit_file'
+          @file_cache.on_write(path) if path
+        when 'bash'
+          invalidate_bash_write_targets(params)
         end
       rescue StandardError
         nil
@@ -109,6 +131,41 @@ module RubynCode
         nil
       end
 
+      # Trigger an incremental codebase index update after writing a Ruby file.
+      # Non-blocking: if the update fails, log and continue.
+      def maybe_update_codebase_index(tool_name, params)
+        return unless %w[write_file edit_file].include?(tool_name)
+        return unless @codebase_index
+
+        path = resolve_cache_path(params)
+        return unless path&.end_with?('.rb')
+
+        @codebase_index.update!
+      rescue StandardError => e
+        RubynCode::Debug.warn("CodebaseIndex incremental update failed: #{e.message}")
+      end
+
+      # Detect file paths that a bash command may have written to and
+      # invalidate them from the file cache.
+      def invalidate_bash_write_targets(params)
+        command = params[:command] || params['command']
+        return unless command.is_a?(String)
+
+        paths = extract_bash_write_paths(command)
+        paths.each do |p|
+          resolved = File.expand_path(p, @project_root)
+          @file_cache.on_write(resolved)
+        end
+      end
+
+      def extract_bash_write_paths(command)
+        paths = []
+        BASH_WRITE_PATTERNS.each do |pattern|
+          command.scan(pattern) { |match| paths << match[0] if match[0] }
+        end
+        paths.uniq
+      end
+
       def error_result(message)
         message
       end

data/lib/rubyn_code/tools/glob.rb

@@ -21,6 +21,12 @@ module RubynCode
       RISK_LEVEL = :read
       REQUIRES_CONFIRMATION = false
 
+      def self.summarize(output, args)
+        pattern = args['pattern'] || args[:pattern] || ''
+        count = output.to_s.strip.empty? ? 0 : output.to_s.lines.count
+        "glob #{pattern} (#{count} files)"
+      end
+
       def execute(pattern:, path: nil)
         search_dir = resolve_search_dir(path)
         full_pattern = File.join(search_dir, pattern)

data/lib/rubyn_code/tools/grep.rb

@@ -20,6 +20,13 @@ module RubynCode
       RISK_LEVEL = :read
       REQUIRES_CONFIRMATION = false
 
+      def self.summarize(output, args)
+        pattern = args['pattern'] || args[:pattern] || ''
+        count = output.to_s.lines.count
+        no_matches = count.zero? || output.to_s.start_with?('No matches')
+        no_matches ? "grep #{pattern} (0 matches)" : "grep #{pattern} (#{count} lines)"
+      end
+
       def execute(pattern:, path: nil, glob_filter: nil, max_results: 50)
         search_path = path ? safe_path(path) : project_root
         regex = Regexp.new(pattern)

data/lib/rubyn_code/tools/ide_diagnostics.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Tools
+    # Retrieves VS Code diagnostics (errors/warnings from the Problems panel)
+    # via the IDE RPC bridge. Only available when running in IDE mode.
+    class IdeDiagnostics < Base
+      TOOL_NAME = 'ide_diagnostics'
+      DESCRIPTION =
+        'Get VS Code diagnostics (errors, warnings) for a file or the whole workspace. ' \
+        'Only available in IDE mode.'
+      PARAMETERS = {
+        file: {
+          type: 'string',
+          description: 'File path to get diagnostics for. Omit to get all workspace diagnostics.'
+        }
+      }.freeze
+      RISK_LEVEL = :read
+
+      def initialize(project_root:, ide_client: nil)
+        super(project_root: project_root)
+        @ide_client = ide_client
+      end
+
+      def execute(**params)
+        unless @ide_client
+          return 'IDE diagnostics are only available when running inside VS Code.'
+        end
+
+        rpc_params = {}
+        rpc_params[:file] = params[:file] if params[:file]
+
+        result = @ide_client.request('ide/getDiagnostics', rpc_params, timeout: 10)
+        diagnostics = result['diagnostics'] || []
+
+        return 'No diagnostics found.' if diagnostics.empty?
+
+        lines = diagnostics.map do |d|
+          severity = d['severity']&.upcase || 'INFO'
+          source = d['source'] ? " (#{d['source']})" : ''
+          "#{severity}: #{d['file']}:#{d['line']} — #{d['message']}#{source}"
+        end
+
+        lines.join("\n")
+      end
+
+      def self.summarize(output, _args)
+        count = output.lines.count
+        "#{count} diagnostic(s)"
+      end
+    end
+  end
+end

data/lib/rubyn_code/tools/ide_symbols.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Tools
+    # Searches VS Code workspace symbols via the language server.
+    # Only available when running in IDE mode.
+    class IdeSymbols < Base
+      TOOL_NAME = 'ide_symbols'
+      DESCRIPTION =
+        'Search workspace symbols (classes, methods, modules) via VS Code language server. ' \
+        'Only available in IDE mode.'
+      PARAMETERS = {
+        query: {
+          type: 'string',
+          description: 'Symbol search query (e.g. "User", "authenticate")',
+          required: true
+        }
+      }.freeze
+      RISK_LEVEL = :read
+
+      def initialize(project_root:, ide_client: nil)
+        super(project_root: project_root)
+        @ide_client = ide_client
+      end
+
+      def execute(**params)
+        unless @ide_client
+          return 'IDE symbols are only available when running inside VS Code.'
+        end
+
+        query = params[:query] || ''
+        return 'Query is required.' if query.empty?
+
+        result = @ide_client.request('ide/getWorkspaceSymbols', { query: query }, timeout: 10)
+        symbols = result['symbols'] || []
+
+        return "No symbols found matching '#{query}'." if symbols.empty?
+
+        lines = symbols.first(50).map do |s|
+          container = s['containerName'] ? " (in #{s['containerName']})" : ''
+          line_info = s['line'] ? ":#{s['line']}" : ''
+          "#{s['kind']} #{s['name']}#{container} — #{s['file']}#{line_info}"
+        end
+
+        header = "Found #{symbols.size} symbol(s) matching '#{query}':"
+        ([header] + lines).join("\n")
+      end
+
+      def self.summarize(output, _args)
+        first_line = output.lines.first&.strip || ''
+        first_line.start_with?('Found') ? first_line : ''
+      end
+    end
+  end
+end

data/lib/rubyn_code/tools/load_skill.rb

@@ -36,7 +36,8 @@ module RubynCode
         skills_dirs = [
           File.expand_path('../../../skills', __dir__), # bundled gem skills
           File.join(project_root, '.rubyn-code', 'skills'), # project skills
-          File.join(Dir.home, '.rubyn-code', 'skills') # global user skills
+          File.join(Dir.home, '.rubyn-code', 'skills'), # global user skills
+          File.join(Dir.home, '.rubyn-code', 'skill-packs') # registry-installed packs
         ]
         catalog = Skills::Catalog.new(skills_dirs.select { |d| Dir.exist?(d) })
         Skills::Loader.new(catalog)

data/lib/rubyn_code/tools/output_compressor.rb

@@ -63,7 +63,12 @@ module RubynCode
         failures = extract_spec_failures(lines)
         return summary_line.strip if failures.empty? && summary_line
 
-        assemble_failure_report(failures, summary_line)
+        result = assemble_failure_report(failures, summary_line)
+
+        # Guard: if compression produced an empty string (no summary line
+        # and no extractable failures), return the original output so the
+        # agent still sees spec results.
+        result.nil? || result.strip.empty? ? output : result
       end
 
       def find_summary_line(lines)
@@ -98,7 +103,7 @@ module RubynCode
         failures
       end
 
-      # rubocop:disable Metrics/AbcSize -- head/tail splitting requires coordinated arithmetic
+      # -- head/tail splitting requires coordinated arithmetic
       def head_tail(output, max_chars)
         lines = output.lines
         return output if lines.size <= 10
@@ -115,9 +120,8 @@ module RubynCode
         parts << tail_lines.join
         parts.join
       end
-      # rubocop:enable Metrics/AbcSize
 
-      # rubocop:disable Metrics/AbcSize -- diff hunk iteration with header extraction
+      # -- diff hunk iteration with header extraction
       def compress_diff(output, max_chars)
         hunks = output.split(/^(?=diff --git)/)
         return head_tail(output, max_chars) if hunks.size <= 1
@@ -135,7 +139,6 @@ module RubynCode
 
         result
       end
-      # rubocop:enable Metrics/AbcSize
 
       def top_matches(output, max_chars)
         lines = output.lines
@@ -147,7 +150,7 @@ module RubynCode
         result
       end
 
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity -- multi-step tree collapse
+      # -- multi-step tree collapse
       def collapse_tree(output, max_chars)
         paths = output.lines.map(&:strip).reject(&:empty?)
         return output if output.length <= max_chars
@@ -159,7 +162,6 @@ module RubynCode
 
         head_tail(result, max_chars)
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
 
       def take_lines_up_to(lines, max_chars)
         taken = []

data/lib/rubyn_code/tools/read_file.rb

@@ -17,6 +17,12 @@ module RubynCode
       RISK_LEVEL = :read
       REQUIRES_CONFIRMATION = false
 
+      def self.summarize(output, args)
+        path = args['path'] || args[:path] || ''
+        line_count = output.to_s.lines.count
+        "Read #{path} (#{line_count} lines)"
+      end
+
       def execute(path:, offset: nil, limit: nil)
         resolved = read_file_safely(path)
         lines = File.readlines(resolved)

data/lib/rubyn_code/tools/registry.rb

@@ -33,15 +33,26 @@ module RubynCode
           @tools = {}
         end
 
+        # IDE-only tools that require an ide_client to function.
+        IDE_ONLY_TOOLS = %w[ide_diagnostics ide_symbols].freeze
+
         def load_all!
           tool_files = Dir[File.join(__dir__, '*.rb')]
           tool_files.each do |file|
             basename = File.basename(file, '.rb')
             next if %w[base registry schema executor].include?(basename)
+            next if IDE_ONLY_TOOLS.include?(basename)
 
             require_relative basename
           end
         end
+
+        # Register IDE-only tools when an ide_client is available.
+        def load_ide_tools!
+          IDE_ONLY_TOOLS.each do |name|
+            require_relative name
+          end
+        end
       end
     end
   end

data/lib/rubyn_code/tools/review_pr.rb

@@ -24,7 +24,7 @@ module RubynCode
       }.freeze
       RISK_LEVEL = :read
 
-      def execute(base_branch: 'main', focus: 'all')
+      def execute(base_branch: 'main', focus: 'all', pack_context: nil)
         error = validate_git_repo
         return error if error
 
@@ -37,7 +37,7 @@ module RubynCode
         diff = run_git("diff #{base_branch}...HEAD")
         return "No changes found between #{current} and #{base_branch}." if diff.strip.empty?
 
-        build_full_review(current, base_branch, diff, focus)
+        build_full_review(current, base_branch, diff, focus, pack_context: pack_context)
       end
 
       FILE_CATEGORIES = [
@@ -80,8 +80,9 @@ module RubynCode
         [nil, "Error: Base branch '#{base_branch}' not found."]
       end
 
-      def build_full_review(current, base_branch, diff, focus)
-        review = build_review_header(current, base_branch)
+      def build_full_review(current, base_branch, diff, focus, pack_context: nil)
+        review = build_pack_context_section(pack_context)
+        review.concat(build_review_header(current, base_branch))
         review.concat(build_file_categories(base_branch))
         review.concat(build_focus_section(focus))
         review.concat(build_diff_section(diff))
@@ -158,6 +159,16 @@ module RubynCode
         ]
       end
 
+      def build_pack_context_section(pack_context)
+        return [] if pack_context.nil? || pack_context.strip.empty?
+
+        [
+          '## Skill Pack Context',
+          pack_context.strip,
+          ''
+        ]
+      end
+
       def run_git(command)
         `cd #{project_root} && git #{command} 2>/dev/null`
       end

data/lib/rubyn_code/tools/web_search.rb

@@ -85,7 +85,8 @@ module RubynCode
         html.scan(%r{<a[^>]+href="(https?://(?!lite\.duckduckgo)[^"]+)"[^>]*>(.*?)</a>}i)
       end
 
-      def build_ddg_results(links, snippets, max) # rubocop:disable Metrics/AbcSize -- HTML parsing with filtering
+      # -- HTML parsing with filtering
+      def build_ddg_results(links, snippets, max)
         results = []
         links.each_with_index do |match, idx|
           break if results.length >= max

data/lib/rubyn_code/tools/write_file.rb

@@ -18,6 +18,12 @@ module RubynCode
 
       PREVIEW_LINES = 15
 
+      # Take the first line of the tool's output, which is already formatted
+      # as "Updated /path.rb (N bytes)" or "Created /path.rb (N bytes)".
+      def self.summarize(output, _args)
+        output.to_s.lines.first.to_s.chomp[0, 200]
+      end
+
       def execute(path:, content:)
         resolved = safe_path(path)
         existed = File.exist?(resolved)
@@ -29,6 +35,17 @@ module RubynCode
         format_result(path, bytes, existed, old_content, content)
       end
 
+      # Compute the proposed file content without writing to disk.
+      # Used by IDE mode to preview the write in a diff view (modify) or
+      # preview tab (create) before the user accepts.
+      #
+      # @return [Hash] { content: String, type: 'modify' | 'create' }
+      def preview_content(path:, content:)
+        resolved = safe_path(path)
+        type = File.exist?(resolved) ? 'modify' : 'create'
+        { content: content, type: type }
+      end
+
       private
 
       def format_result(path, bytes, existed, old_content, new_content)

data/lib/rubyn_code/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubynCode
-  VERSION = '0.3.0'
+  VERSION = '0.5.0'
 end

data/lib/rubyn_code.rb

@@ -11,6 +11,10 @@ module RubynCode
   class StallDetectedError < Error; end
   class ToolNotFoundError < Error; end
   class ConfigError < Error; end
+  # Raised when the user refuses a tool invocation in IDE mode. Signals the
+  # agent loop to surface this as is_error: true so the model sees a refusal
+  # rather than a successful tool call returning a string like "denied".
+  class UserDeniedError < Error; end
 
   # Infrastructure
   autoload :Config, 'rubyn_code/config/settings'
@@ -29,6 +33,7 @@ module RubynCode
   # Auth
   module Auth
     autoload :OAuth, 'rubyn_code/auth/oauth'
+    autoload :KeyEncryption, 'rubyn_code/auth/key_encryption'
     autoload :TokenStore, 'rubyn_code/auth/token_store'
     autoload :Server, 'rubyn_code/auth/server'
   end
@@ -45,6 +50,7 @@ module RubynCode
       autoload :JsonParsing, 'rubyn_code/llm/adapters/json_parsing'
       autoload :PromptCaching, 'rubyn_code/llm/adapters/prompt_caching'
       autoload :Anthropic, 'rubyn_code/llm/adapters/anthropic'
+      autoload :AnthropicCompatible, 'rubyn_code/llm/adapters/anthropic_compatible'
       autoload :AnthropicStreaming, 'rubyn_code/llm/adapters/anthropic_streaming'
       autoload :OpenAI, 'rubyn_code/llm/adapters/openai'
       autoload :OpenAIStreaming, 'rubyn_code/llm/adapters/openai_streaming'
@@ -131,7 +137,16 @@ module RubynCode
     autoload :Loader, 'rubyn_code/skills/loader'
     autoload :Catalog, 'rubyn_code/skills/catalog'
     autoload :Document, 'rubyn_code/skills/document'
+    autoload :Matcher, 'rubyn_code/skills/matcher'
+    autoload :RegistryAutoload, 'rubyn_code/skills/registry_autoload'
     autoload :TtlManager, 'rubyn_code/skills/ttl_manager'
+    autoload :RegistryClient, 'rubyn_code/skills/registry_client'
+    autoload :PackManager, 'rubyn_code/skills/pack_manager'
+    autoload :PackInstaller, 'rubyn_code/skills/pack_installer'
+    autoload :PackContext, 'rubyn_code/skills/pack_context'
+    autoload :GemfileParser, 'rubyn_code/skills/gemfile_parser'
+    autoload :AutoSuggest, 'rubyn_code/skills/auto_suggest'
+    autoload :RegistryError, 'rubyn_code/skills/registry_client'
   end
 
   # Layer 6: Sub-Agents
@@ -220,6 +235,19 @@ module RubynCode
     autoload :Shortcut, 'rubyn_code/learning/shortcut'
   end
 
+  # IDE (VS Code extension server)
+  module IDE
+    autoload :Protocol, 'rubyn_code/ide/protocol'
+    autoload :Server, 'rubyn_code/ide/server'
+
+    module Adapters
+      autoload :ToolOutput, 'rubyn_code/ide/adapters/tool_output'
+    end
+  end
+
+  # Self-Test
+  autoload :SelfTest, 'rubyn_code/self_test'
+
   # Codebase Index
   module Index
     autoload :CodebaseIndex, 'rubyn_code/index/codebase_index'
@@ -234,6 +262,7 @@ module RubynCode
     autoload :Spinner, 'rubyn_code/cli/spinner'
     autoload :StreamFormatter, 'rubyn_code/cli/stream_formatter'
     autoload :Setup, 'rubyn_code/cli/setup'
+    autoload :FirstRun, 'rubyn_code/cli/first_run'
     autoload :DaemonRunner, 'rubyn_code/cli/daemon_runner'
     autoload :VersionCheck, 'rubyn_code/cli/version_check'
 
@@ -260,8 +289,13 @@ module RubynCode
       autoload :Plan, 'rubyn_code/cli/commands/plan'
       autoload :ContextInfo, 'rubyn_code/cli/commands/context_info'
       autoload :Diff, 'rubyn_code/cli/commands/diff'
+      autoload :Mcp, 'rubyn_code/cli/commands/mcp'
       autoload :Model, 'rubyn_code/cli/commands/model'
       autoload :NewSession, 'rubyn_code/cli/commands/new_session'
+      autoload :Provider, 'rubyn_code/cli/commands/provider'
+      autoload :InstallSkills, 'rubyn_code/cli/commands/install_skills'
+      autoload :RemoveSkills, 'rubyn_code/cli/commands/remove_skills'
+      autoload :Skills, 'rubyn_code/cli/commands/skills'
     end
   end