rubyn-code 0.2.2 → 0.4.0

data/lib/rubyn_code/tools/web_fetch.rb

@@ -8,68 +8,62 @@ module RubynCode
   module Tools
     class WebFetch < Base
       TOOL_NAME = 'web_fetch'
-      DESCRIPTION = 'Fetch the content of a web page and return it as text. Useful for reading documentation, READMEs, or API docs.'
+      DESCRIPTION = 'Fetch the content of a web page and return it as text. ' \
+                    'Useful for reading documentation, READMEs, or API docs.'
       PARAMETERS = {
-        url: { type: :string, required: true, description: 'The URL to fetch (must start with http:// or https://)' },
-        max_length: { type: :integer, required: false, default: 10_000,
-                      description: 'Maximum number of characters to return (default: 10000)' }
+        url: {
+          type: :string, required: true,
+          description: 'The URL to fetch (must start with http:// or https://)'
+        },
+        max_length: {
+          type: :integer, required: false, default: 10_000,
+          description: 'Maximum number of characters to return (default: 10000)'
+        }
       }.freeze
       RISK_LEVEL = :external
       REQUIRES_CONFIRMATION = true
 
+      MAX_REDIRECTS = 5
+      REDIRECT_STATUSES = [301, 302, 303, 307, 308].freeze
+
       def execute(url:, max_length: 10_000)
         validate_url!(url)
-        max_length = [[max_length.to_i, 500].max, 100_000].min
+        max_length = max_length.to_i.clamp(500, 100_000)
 
         response = fetch_page(url)
         text = html_to_text(response.body)
         text = collapse_whitespace(text)
 
-        if text.strip.empty?
-          "Fetched #{url} but no readable text content was found."
-        else
-          header = "Content from: #{url}\n#{'=' * 60}\n\n"
-          available = max_length - header.length
-          content = if text.length > available
-                      "#{text[0,
-                              available]}\n\n... [truncated at #{max_length} characters]"
-                    else
-                      text
-                    end
-          "#{header}#{content}"
-        end
+        format_fetched_content(url, text, max_length)
       end
 
       private
 
+      def format_fetched_content(url, text, max_length)
+        return "Fetched #{url} but no readable text content was found." if text.strip.empty?
+
+        header = "Content from: #{url}\n#{'=' * 60}\n\n"
+        available = max_length - header.length
+        content = text.length > available ? truncate_content(text, available, max_length) : text
+        "#{header}#{content}"
+      end
+
+      def truncate_content(text, available, max_length)
+        "#{text[0, available]}\n\n... [truncated at #{max_length} characters]"
+      end
+
       def validate_url!(url)
         return if url.match?(%r{\Ahttps?://}i)
 
-        raise Error, "Invalid URL: must start with http:// or https:// — got: #{url}"
+        raise Error,
+              "Invalid URL: must start with http:// or https:// — got: #{url}"
       end
 
-      MAX_REDIRECTS = 5
-
       def fetch_page(url, redirects: 0)
-        conn = Faraday.new do |f|
-          f.options.timeout = 30
-          f.options.open_timeout = 10
-          f.headers['User-Agent'] = 'Mozilla/5.0 (compatible; RubynCode/1.0)'
-          f.headers['Accept'] = 'text/html,application/xhtml+xml,text/plain,*/*'
-        end
-
+        conn = build_connection
         response = conn.get(url)
 
-        if [301, 302, 303, 307, 308].include?(response.status)
-          raise Error, "Too many redirects fetching #{url}" if redirects >= MAX_REDIRECTS
-
-          location = response.headers['location']
-          raise Error, "Redirect with no Location header from #{url}" unless location
-
-          location = URI.join(url, location).to_s unless location.start_with?('http')
-          return fetch_page(location, redirects: redirects + 1)
-        end
-
+        return handle_redirect(url, response, redirects) if REDIRECT_STATUSES.include?(response.status)
         raise Error, "HTTP #{response.status} fetching #{url}" unless response.success?
 
         response
@@ -81,24 +75,48 @@ module RubynCode
         raise Error, "Request failed for #{url}: #{e.message}"
       end
 
+      def build_connection
+        Faraday.new do |f|
+          f.options.timeout = 30
+          f.options.open_timeout = 10
+          f.headers['User-Agent'] = 'Mozilla/5.0 (compatible; RubynCode/1.0)'
+          f.headers['Accept'] = 'text/html,application/xhtml+xml,text/plain,*/*'
+        end
+      end
+
+      def handle_redirect(url, response, redirects)
+        raise Error, "Too many redirects fetching #{url}" if redirects >= MAX_REDIRECTS
+
+        location = response.headers['location']
+        raise Error, "Redirect with no Location header from #{url}" unless location
+
+        location = URI.join(url, location).to_s unless location.start_with?('http')
+        fetch_page(location, redirects: redirects + 1)
+      end
+
       def html_to_text(html)
         return '' if html.nil? || html.empty?
 
         text = html.dup
+        strip_scripts_and_styles!(text)
+        convert_block_elements!(text)
+        text.gsub!(/<[^>]*>/, '')
+        decode_html_entities!(text)
+        text
+      end
 
-        # Remove script and style blocks entirely
+      def strip_scripts_and_styles!(text)
         text.gsub!(%r{<script[^>]*>.*?</script>}mi, '')
         text.gsub!(%r{<style[^>]*>.*?</style>}mi, '')
+      end
 
-        # Convert common block elements to newlines
+      def convert_block_elements!(text)
         text.gsub!(%r{<br\s*/?>}i, "\n")
         text.gsub!(%r{</(p|div|h[1-6]|li|tr|blockquote|pre)>}i, "\n")
         text.gsub!(/<(p|div|h[1-6]|li|tr|blockquote|pre)[^>]*>/i, "\n")
+      end
 
-        # Strip all remaining HTML tags
-        text.gsub!(/<[^>]*>/, '')
-
-        # Decode common HTML entities
+      def decode_html_entities!(text)
         text.gsub!('&amp;', '&')
         text.gsub!('&lt;', '<')
         text.gsub!('&gt;', '>')
@@ -106,12 +124,9 @@ module RubynCode
         text.gsub!('&#39;', "'")
         text.gsub!('&nbsp;', ' ')
         text.gsub!(/&#(\d+);/) { [::Regexp.last_match(1).to_i].pack('U') }
-
-        text
       end
 
       def collapse_whitespace(text)
-        # Collapse runs of spaces/tabs on each line, then collapse 3+ newlines into 2
         text.gsub(/[^\S\n]+/, ' ')
             .gsub(/\n{3,}/, "\n\n")
             .strip

data/lib/rubyn_code/tools/web_search.rb

@@ -14,12 +14,15 @@ module RubynCode
       DESCRIPTION = 'Search the web for information. Returns search results with titles, URLs, and snippets.'
       PARAMETERS = {
         query: { type: :string, required: true, description: 'The search query string' },
-        num_results: { type: :integer, required: false, default: 5, description: 'Number of results (default: 5)' }
+        num_results: {
+          type: :integer, required: false, default: 5,
+          description: 'Number of results (default: 5)'
+        }
       }.freeze
       RISK_LEVEL = :external
       REQUIRES_CONFIRMATION = true
 
-      # Adapter registry — add new providers here
+      # Adapter registry -- add new providers here
       ADAPTERS = {
         'duckduckgo' => :search_duckduckgo,
         'brave' => :search_brave,
@@ -29,7 +32,7 @@ module RubynCode
       }.freeze
 
       def execute(query:, num_results: 5)
-        num_results = [[num_results.to_i, 1].max, 20].min
+        num_results = num_results.to_i.clamp(1, 20)
         provider = detect_provider
 
         results = send(ADAPTERS[provider], query, num_results)
@@ -45,24 +48,24 @@ module RubynCode
 
       private
 
-      # Pick the best available provider based on env vars
       def detect_provider
-        return 'tavily'     if ENV['TAVILY_API_KEY']
-        return 'brave'      if ENV['BRAVE_API_KEY']
+        return 'tavily'  if ENV['TAVILY_API_KEY']
+        return 'brave'   if ENV['BRAVE_API_KEY']
         return 'serpapi' if ENV['SERPAPI_API_KEY']
         return 'google' if ENV['GOOGLE_SEARCH_API_KEY'] && ENV['GOOGLE_SEARCH_CX']
 
         'duckduckgo'
       end
 
-      # ─── DuckDuckGo (no API key, free) ───
+      # --- DuckDuckGo (no API key, free) ---
 
       def search_duckduckgo(query, num_results)
         encoded = CGI.escape(query)
+        url = "https://lite.duckduckgo.com/lite/?q=#{encoded}"
         stdout, _, status = safe_capture3(
           'curl', '-sL', '--max-time', '15',
           '-H', 'User-Agent: Mozilla/5.0 (compatible; RubynCode/1.0)',
-          "https://lite.duckduckgo.com/lite/?q=#{encoded}"
+          url
         )
         return [] unless status.success?
 
@@ -70,11 +73,20 @@ module RubynCode
       end
 
       def parse_duckduckgo(html, max)
-        results = []
-        links = html.scan(%r{<a[^>]+rel="nofollow"[^>]+href="([^"]+)"[^>]*>(.*?)</a>}i)
-        links = html.scan(%r{<a[^>]+href="(https?://(?!lite\.duckduckgo)[^"]+)"[^>]*>(.*?)</a>}i) if links.empty?
+        links = extract_ddg_links(html)
         snippets = html.scan(%r{<td[^>]*class="result-snippet"[^>]*>(.*?)</td>}im)
+        build_ddg_results(links, snippets, max)
+      end
+
+      def extract_ddg_links(html)
+        links = html.scan(%r{<a[^>]+rel="nofollow"[^>]+href="([^"]+)"[^>]*>(.*?)</a>}i)
+        return links unless links.empty?
+
+        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
+        results = []
         links.each_with_index do |match, idx|
           break if results.length >= max
 
@@ -85,14 +97,21 @@ module RubynCode
           snippet = snippets[idx] ? strip_html(snippets[idx][0]).strip : ''
           results << { title: title, url: url, snippet: snippet }
         end
-
         results
       end
 
-      # ─── Brave Search (free tier: 2000 queries/mo) ───
+      # --- Brave Search (free tier: 2000 queries/mo) ---
 
       def search_brave(query, num_results)
-        resp = Faraday.get('https://api.search.brave.com/res/v1/web/search') do |req|
+        resp = brave_request(query, num_results)
+        data = JSON.parse(resp.body)
+        (data.dig('web', 'results') || []).map do |r|
+          { title: r['title'], url: r['url'], snippet: r['description'] || '' }
+        end
+      end
+
+      def brave_request(query, num_results)
+        Faraday.get('https://api.search.brave.com/res/v1/web/search') do |req|
           req.params['q'] = query
           req.params['count'] = num_results
           req.headers['Accept'] = 'application/json'
@@ -100,72 +119,71 @@ module RubynCode
           req.headers['X-Subscription-Token'] = ENV.fetch('BRAVE_API_KEY', nil)
           req.options.timeout = 15
         end
-
-        data = JSON.parse(resp.body)
-        (data.dig('web', 'results') || []).map do |r|
-          { title: r['title'], url: r['url'], snippet: r['description'] || '' }
-        end
       end
 
-      # ─── Tavily (built for AI agents, free tier: 1000 queries/mo) ───
+      # --- Tavily (built for AI agents, free tier: 1000 queries/mo) ---
 
       def search_tavily(query, num_results)
-        resp = Faraday.post('https://api.tavily.com/search') do |req|
-          req.headers['Content-Type'] = 'application/json'
-          req.body = JSON.generate({
-                                     api_key: ENV.fetch('TAVILY_API_KEY', nil),
-                                     query: query,
-                                     max_results: num_results,
-                                     include_answer: true
-                                   })
-          req.options.timeout = 15
-        end
-
+        resp = tavily_request(query, num_results)
         data = JSON.parse(resp.body)
         results = (data['results'] || []).map do |r|
           { title: r['title'], url: r['url'], snippet: r['content'] || '' }
         end
-
-        # Tavily provides a direct answer — prepend it
-        results.unshift({ title: 'AI Answer', url: '', snippet: data['answer'] }) if data['answer']
-
+        results.unshift(title: 'AI Answer', url: '', snippet: data['answer']) if data['answer']
         results
       end
 
-      # ─── SerpAPI (free tier: 100 queries/mo) ───
+      def tavily_request(query, num_results)
+        Faraday.post('https://api.tavily.com/search') do |req|
+          req.headers['Content-Type'] = 'application/json'
+          req.body = JSON.generate(
+            api_key: ENV.fetch('TAVILY_API_KEY', nil),
+            query: query, max_results: num_results, include_answer: true
+          )
+          req.options.timeout = 15
+        end
+      end
+
+      # --- SerpAPI (free tier: 100 queries/mo) ---
 
       def search_serpapi(query, num_results)
-        resp = Faraday.get('https://serpapi.com/search.json') do |req|
+        resp = serpapi_request(query, num_results)
+        data = JSON.parse(resp.body)
+        (data['organic_results'] || []).map do |r|
+          { title: r['title'], url: r['link'], snippet: r['snippet'] || '' }
+        end
+      end
+
+      def serpapi_request(query, num_results)
+        Faraday.get('https://serpapi.com/search.json') do |req|
           req.params['q'] = query
           req.params['num'] = num_results
           req.params['api_key'] = ENV.fetch('SERPAPI_API_KEY', nil)
           req.options.timeout = 15
         end
+      end
+
+      # --- Google Custom Search (free tier: 100 queries/day) ---
 
+      def search_google(query, num_results)
+        resp = google_request(query, num_results)
         data = JSON.parse(resp.body)
-        (data['organic_results'] || []).map do |r|
+        (data['items'] || []).map do |r|
           { title: r['title'], url: r['link'], snippet: r['snippet'] || '' }
         end
       end
 
-      # ─── Google Custom Search (free tier: 100 queries/day) ───
-
-      def search_google(query, num_results)
-        resp = Faraday.get('https://www.googleapis.com/customsearch/v1') do |req|
+      def google_request(query, num_results)
+        Faraday.get('https://www.googleapis.com/customsearch/v1') do |req|
           req.params['q'] = query
           req.params['num'] = [num_results, 10].min
           req.params['key'] = ENV.fetch('GOOGLE_SEARCH_API_KEY', nil)
           req.params['cx'] = ENV.fetch('GOOGLE_SEARCH_CX', nil)
           req.options.timeout = 15
         end
-
-        data = JSON.parse(resp.body)
-        (data['items'] || []).map do |r|
-          { title: r['title'], url: r['link'], snippet: r['snippet'] || '' }
-        end
       end
 
-      # ─── Shared ───
+      # --- Shared ---
 
       def strip_html(text)
         return '' if text.nil?

data/lib/rubyn_code/tools/write_file.rb

@@ -16,13 +16,88 @@ module RubynCode
       RISK_LEVEL = :write
       REQUIRES_CONFIRMATION = false
 
+      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)
+        old_content = existed ? File.read(resolved) : nil
 
         FileUtils.mkdir_p(File.dirname(resolved))
         bytes = File.write(resolved, content)
 
-        "Successfully wrote #{bytes} bytes to #{path}"
+        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)
+        lines = []
+
+        if existed
+          lines << "Updated #{path} (#{bytes} bytes)"
+          lines << diff_preview(old_content, new_content)
+        else
+          lines << "Created #{path} (#{bytes} bytes)"
+          lines << file_preview(new_content)
+        end
+
+        lines.compact.join("\n")
+      end
+
+      def file_preview(content)
+        preview_lines = content.lines.first(PREVIEW_LINES)
+        preview = preview_lines.each_with_index.map do |line, idx|
+          "  #{(idx + 1).to_s.rjust(3)}│ #{line.chomp}"
+        end.join("\n")
+
+        remaining = content.lines.count - PREVIEW_LINES
+        preview += "\n  ... (#{remaining} more lines)" if remaining.positive?
+        preview
+      end
+
+      def diff_preview(old_content, new_content)
+        old_lines = (old_content || '').lines.map(&:chomp)
+        new_lines = new_content.lines.map(&:chomp)
+
+        changes = simple_diff(old_lines, new_lines)
+        return '  (no visible changes)' if changes.empty?
+
+        changes.first(20).join("\n")
+      end
+
+      def simple_diff(old_lines, new_lines)
+        changes = []
+        max = [old_lines.length, new_lines.length].max
+
+        max.times do |idx|
+          old_line = old_lines[idx]
+          new_line = new_lines[idx]
+
+          next if old_line == new_line
+
+          changes << "  - #{old_line}" if old_line
+          changes << "  + #{new_line}" if new_line
+        end
+
+        changes
       end
     end
 

data/lib/rubyn_code/version.rb

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

data/lib/rubyn_code.rb

@@ -11,10 +11,18 @@ 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'
 
+  module Config
+    autoload :ProjectProfile, 'rubyn_code/config/project_profile'
+  end
+
   # Database
   module DB
     autoload :Connection, 'rubyn_code/db/connection'
@@ -25,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
@@ -32,8 +41,25 @@ module RubynCode
   # LLM
   module LLM
     autoload :Client, 'rubyn_code/llm/client'
-    autoload :Streaming, 'rubyn_code/llm/streaming'
     autoload :MessageBuilder, 'rubyn_code/llm/message_builder'
+    autoload :ModelRouter, 'rubyn_code/llm/model_router'
+
+    # Adapters (provider-specific implementations)
+    module Adapters
+      autoload :Base, 'rubyn_code/llm/adapters/base'
+      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'
+      autoload :OpenAICompatible, 'rubyn_code/llm/adapters/openai_compatible'
+      autoload :OpenAIMessageTranslator, 'rubyn_code/llm/adapters/openai_message_translator'
+    end
+
+    # Backward-compat: LLM::Streaming → Adapters::AnthropicStreaming
+    autoload :Streaming, 'rubyn_code/llm/streaming'
   end
 
   # Layer 1: Agent Loop
@@ -41,6 +67,8 @@ module RubynCode
     autoload :Loop, 'rubyn_code/agent/loop'
     autoload :LoopDetector, 'rubyn_code/agent/loop_detector'
     autoload :Conversation, 'rubyn_code/agent/conversation'
+    autoload :ResponseModes, 'rubyn_code/agent/response_modes'
+    autoload :DynamicToolSchema, 'rubyn_code/agent/dynamic_tool_schema'
   end
 
   # Layer 2: Tool System
@@ -72,11 +100,15 @@ module RubynCode
     autoload :BackgroundRun, 'rubyn_code/tools/background_run'
     autoload :WebSearch, 'rubyn_code/tools/web_search'
     autoload :WebFetch, 'rubyn_code/tools/web_fetch'
+    autoload :AskUser, 'rubyn_code/tools/ask_user'
     autoload :GitCommit, 'rubyn_code/tools/git_commit'
     autoload :GitDiff, 'rubyn_code/tools/git_diff'
     autoload :GitLog, 'rubyn_code/tools/git_log'
     autoload :GitStatus, 'rubyn_code/tools/git_status'
     autoload :SpawnTeammate, 'rubyn_code/tools/spawn_teammate'
+    autoload :OutputCompressor, 'rubyn_code/tools/output_compressor'
+    autoload :FileCache, 'rubyn_code/tools/file_cache'
+    autoload :SpecOutputParser, 'rubyn_code/tools/spec_output_parser'
   end
 
   # Layer 3: Permissions
@@ -95,6 +127,9 @@ module RubynCode
     autoload :AutoCompact, 'rubyn_code/context/auto_compact'
     autoload :ManualCompact, 'rubyn_code/context/manual_compact'
     autoload :ContextCollapse, 'rubyn_code/context/context_collapse'
+    autoload :ContextBudget, 'rubyn_code/context/context_budget'
+    autoload :SchemaFilter, 'rubyn_code/context/schema_filter'
+    autoload :DecisionCompactor, 'rubyn_code/context/decision_compactor'
   end
 
   # Layer 5: Skills
@@ -102,6 +137,7 @@ module RubynCode
     autoload :Loader, 'rubyn_code/skills/loader'
     autoload :Catalog, 'rubyn_code/skills/catalog'
     autoload :Document, 'rubyn_code/skills/document'
+    autoload :TtlManager, 'rubyn_code/skills/ttl_manager'
   end
 
   # Layer 6: Sub-Agents
@@ -160,6 +196,8 @@ module RubynCode
     autoload :BudgetEnforcer, 'rubyn_code/observability/budget_enforcer'
     autoload :UsageReporter, 'rubyn_code/observability/usage_reporter'
     autoload :Models, 'rubyn_code/observability/models'
+    autoload :TokenAnalytics, 'rubyn_code/observability/token_analytics'
+    autoload :SkillAnalytics, 'rubyn_code/observability/skill_analytics'
   end
 
   # Layer 14: Hooks
@@ -185,6 +223,25 @@ module RubynCode
     autoload :Instinct, 'rubyn_code/learning/instinct'
     autoload :InstinctMethods, 'rubyn_code/learning/instinct'
     autoload :Injector, 'rubyn_code/learning/injector'
+    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'
   end
 
   # CLI
@@ -196,6 +253,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'
 
@@ -222,7 +280,10 @@ 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'
     end
   end