rubyn-code 0.3.0 → 0.4.0

data/lib/rubyn_code/llm/adapters/anthropic.rb

@@ -48,6 +48,10 @@ module RubynCode
 
         private
 
+        def api_url
+          API_URL
+        end
+
         # -- Auth ---------------------------------------------------------
 
         def oauth_token?
@@ -88,7 +92,7 @@ module RubynCode
         end
 
         def post_request(body)
-          connection.post(API_URL) do |req|
+          connection.post(api_url) do |req|
             apply_headers(req)
             req.body = JSON.generate(body)
           end
@@ -113,7 +117,7 @@ module RubynCode
           streamer = build_streamer(on_text)
           error_chunks = []
 
-          response = streaming_connection.post(API_URL) do |req|
+          response = streaming_connection.post(api_url) do |req|
             apply_headers(req)
             req.body = JSON.generate(body)
             req.options.on_data = on_data_proc(streamer, error_chunks)

data/lib/rubyn_code/llm/adapters/anthropic_compatible.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module LLM
+    module Adapters
+      # Adapter for Anthropic-compatible providers that use the Messages API format.
+      #
+      # Inherits all Anthropic logic but overrides the base URL, provider name,
+      # available models, and API key resolution.
+      class AnthropicCompatible < Anthropic
+        def initialize(provider:, base_url:, api_key: nil, available_models: [])
+          super()
+          @provider = provider
+          @base_url = base_url
+          @api_key = api_key
+          @available_models = available_models.freeze
+        end
+
+        def provider_name
+          @provider
+        end
+
+        def models
+          @available_models
+        end
+
+        private
+
+        def api_url
+          "#{@base_url}/messages"
+        end
+
+        def ensure_valid_token!
+          resolve_api_key # raises if missing
+        end
+
+        def oauth_token?
+          false
+        end
+
+        def access_token
+          resolve_api_key
+        end
+
+        def resolve_api_key
+          return @api_key if @api_key
+
+          stored = Auth::TokenStore.load_provider_key(@provider)
+          return stored if stored
+
+          env_key = "#{@provider.upcase.tr('-', '_')}_API_KEY"
+          ENV.fetch(env_key) do
+            raise Client::AuthExpiredError,
+                  "No #{@provider} API key configured. Set with: /provider set-key #{@provider} <key>"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/llm/adapters/openai_compatible.rb

@@ -27,11 +27,15 @@ module RubynCode
         def resolve_api_key
           return @api_key if @api_key
 
-          env_key = "#{@provider.upcase}_API_KEY"
+          stored = Auth::TokenStore.load_provider_key(@provider)
+          return stored if stored
+
+          env_key = "#{@provider.upcase.tr('-', '_')}_API_KEY"
           ENV.fetch(env_key) do
             return 'no-key-required' if local_provider?
 
-            raise Client::AuthExpiredError, "No #{@provider} API key configured. Set #{env_key}."
+            raise Client::AuthExpiredError,
+                  "No #{@provider} API key configured. Set with: /provider set-key #{@provider} <key>"
           end
         end
 

data/lib/rubyn_code/llm/client.rb

@@ -18,8 +18,9 @@ module RubynCode
       attr_accessor :model
 
       def initialize(model: nil, provider: nil, adapter: nil)
-        @model = model || Config::Defaults::DEFAULT_MODEL
-        @provider = provider || Config::Defaults::DEFAULT_PROVIDER
+        settings = Config::Settings.new
+        @model = model || settings.model
+        @provider = provider || settings.provider
         @adapter = adapter || resolve_adapter(@provider)
       end
 
@@ -65,6 +66,22 @@ module RubynCode
 
       private
 
+      def build_custom_adapter(provider, config, base_url, available_models)
+        case config.fetch('api_format', 'openai')
+        when 'anthropic'
+          Adapters::AnthropicCompatible.new(provider: provider, base_url: base_url, available_models: available_models)
+        else
+          Adapters::OpenAICompatible.new(provider: provider, base_url: base_url, available_models: available_models)
+        end
+      end
+
+      def extract_model_names(config)
+        raw = config&.dig('models')
+        return [] unless raw
+
+        raw.is_a?(Hash) ? raw.values : Array(raw)
+      end
+
       # Builds the appropriate adapter for a given provider name.
       def resolve_adapter(provider)
         case provider
@@ -74,12 +91,20 @@ module RubynCode
           config = Config::Settings.new.provider_config(provider)
           base_url = config&.fetch('base_url', nil)
 
+          if config.nil?
+            raise ConfigError,
+                  "Unknown provider '#{provider}'. " \
+                  "Add it to config.yml under providers.#{provider} with base_url, env_key, and models."
+          end
+
           unless base_url
             raise ConfigError,
-                  "Unknown provider '#{provider}'. Add base_url to config.yml under providers.#{provider}"
+                  "Provider '#{provider}' is missing base_url in config.yml. " \
+                  "Add base_url under providers.#{provider} (e.g., base_url: https://api.#{provider}.com/v1)"
           end
 
-          Adapters::OpenAICompatible.new(provider: provider, base_url: base_url)
+          available_models = extract_model_names(config)
+          build_custom_adapter(provider, config, base_url, available_models)
         end
       end
     end

data/lib/rubyn_code/mcp/config.rb

@@ -49,7 +49,8 @@ module RubynCode
         def parse_servers(servers)
           servers.map do |name, server_def|
             { name: name, command: server_def['command'],
-              args: Array(server_def['args']), env: expand_env(server_def['env'] || {}) }
+              args: Array(server_def['args']), env: expand_env(server_def['env'] || {}),
+              url: server_def['url'], timeout: server_def['timeout'] }
           end
         end
 

data/lib/rubyn_code/memory/search.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'json'
+require_relative 'models'
 
 module RubynCode
   module Memory

data/lib/rubyn_code/self_test.rb

@@ -0,0 +1,315 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module RubynCode
+  # Programmatic smoke test that exercises every major subsystem.
+  # Mirrors the checks in skills/rubyn_self_test.md but runs without
+  # the REPL or an LLM — suitable for CI and rake tasks.
+  #
+  # rubocop:disable Metrics/ClassLength -- intentionally comprehensive
+  class SelfTest
+    Result = Data.define(:name, :passed, :detail)
+
+    attr_reader :results, :project_root
+
+    def initialize(project_root: Dir.pwd)
+      @project_root = project_root
+      @results = []
+    end
+
+    def run! # rubocop:disable Naming/PredicateMethod -- returns bool but primary purpose is side effects
+      @results = []
+
+      check_file_operations
+      check_search
+      check_bash
+      check_git
+      check_specs
+      check_compressor_strategies
+      check_skills
+      check_config
+      check_codebase_index
+      check_slash_commands
+      check_architecture
+
+      print_scorecard
+      results.all?(&:passed)
+    end
+
+    private
+
+    # ── 1. File Operations ──────────────────────────────────────────
+
+    def check_file_operations
+      check_file_read
+      check_file_write_edit_cleanup
+    rescue StandardError => e
+      record('File operations', false, e.message)
+    end
+
+    def check_file_read
+      content = File.read(File.join(project_root, 'lib/rubyn_code/version.rb'))
+      record('File read (version.rb)', content.include?('VERSION ='))
+    end
+
+    def check_file_write_edit_cleanup # rubocop:disable Metrics/AbcSize -- sequential file ops
+      tmp = File.join(project_root, '.rubyn-code/self_test_tmp.rb')
+      FileUtils.mkdir_p(File.dirname(tmp))
+
+      File.write(tmp, '# self-test')
+      record('File write (tmp)', File.exist?(tmp))
+
+      File.write(tmp, File.read(tmp).sub('# self-test', '# self-test passed'))
+      record('File edit (tmp)', File.read(tmp).include?('# self-test passed'))
+
+      File.delete(tmp)
+      record('File cleanup (tmp)', !File.exist?(tmp))
+    end
+
+    # ── 2. Search ───────────────────────────────────────────────────
+
+    def check_search
+      rb_files = Dir.glob(File.join(project_root, 'lib/**/*.rb'))
+      record('Glob lib/**/*.rb', rb_files.size >= 50, "#{rb_files.size} files")
+
+      base_classes = rb_files.count { |f| File.read(f).match?(/class.*Base/) }
+      record('Grep class.*Base', base_classes >= 3, "#{base_classes} matches")
+    rescue StandardError => e
+      record('Search', false, e.message)
+    end
+
+    # ── 3. Bash ─────────────────────────────────────────────────────
+
+    def check_bash
+      ruby_v = `ruby --version 2>&1`.strip
+      record('Bash: ruby --version', ruby_v.include?('ruby'), ruby_v)
+
+      rubocop_v = `bundle exec rubocop --version 2>&1`.strip
+      record('Bash: rubocop --version', rubocop_v.match?(/\d+\.\d+/), rubocop_v)
+    rescue StandardError => e
+      record('Bash', false, e.message)
+    end
+
+    # ── 4. Git ──────────────────────────────────────────────────────
+
+    def check_git
+      run_cmd('git status --short')
+      record('Git status', true)
+
+      log = run_cmd('git log --oneline -3')
+      record('Git log', log.match?(/^[0-9a-f]+/), log.lines.first&.strip)
+
+      run_cmd('git diff --stat')
+      record('Git diff', true)
+    rescue StandardError => e
+      record('Git', false, e.message)
+    end
+
+    # ── 5. Specs ────────────────────────────────────────────────────
+
+    def check_specs
+      %w[
+        spec/rubyn_code/tools/output_compressor_spec.rb
+        spec/rubyn_code/llm/model_router_spec.rb
+      ].each { |spec| run_single_spec(spec) }
+    rescue StandardError => e
+      record('Specs', false, e.message)
+    end
+
+    def run_single_spec(spec)
+      path = File.join(project_root, spec)
+      unless File.exist?(path)
+        record("RSpec: #{File.basename(spec)}", false, 'file not found')
+        return
+      end
+      output = run_cmd("bundle exec rspec #{path} --format progress 2>&1")
+      record("RSpec: #{File.basename(spec)}", output.include?('0 failures'))
+    end
+
+    # ── 6. Output Compressor ────────────────────────────────────────
+
+    def check_compressor_strategies
+      compressor = Tools::OutputCompressor.new
+      verified = 0
+
+      verified += verify_head_tail(compressor)
+      verified += verify_spec_summary(compressor)
+      verified += verify_top_matches(compressor)
+      verified += verify_tree_collapse(compressor)
+      verified += verify_diff_hunks(compressor)
+
+      record('Compression strategies verified', verified >= 3, "#{verified}/5 active")
+    rescue StandardError => e
+      record('Output compressor', false, e.message)
+    end
+
+    def verify_head_tail(compressor)
+      big = (1..5000).to_a.join("\n")
+      compressed = compressor.compress('bash', big)
+      pass = compressed.length < big.length
+      record('Compressor: head_tail', pass)
+      pass ? 1 : 0
+    end
+
+    def verify_spec_summary(compressor)
+      spec_out = run_cmd(
+        'bundle exec rspec spec/rubyn_code/tools/base_spec.rb --format documentation 2>&1'
+      )
+      compressed = compressor.compress('run_specs', spec_out)
+      pass = compressed.length < spec_out.length || compressed.include?('0 failures')
+      record('Compressor: spec_summary', pass)
+      pass ? 1 : 0
+    end
+
+    def verify_top_matches(compressor)
+      grep_out = rb_files_with_def.join("\n")
+      compressed = compressor.compress('grep', grep_out)
+      pass = compressed.length <= grep_out.length
+      record('Compressor: top_matches', pass)
+      pass ? 1 : 0
+    end
+
+    def verify_tree_collapse(compressor)
+      all_rb = Dir.glob(File.join(project_root, '**/*.rb')).join("\n")
+      compressed = compressor.compress('glob', all_rb)
+      pass = compressed.length <= all_rb.length
+      record('Compressor: tree_collapse', pass)
+      pass ? 1 : 0
+    end
+
+    def verify_diff_hunks(compressor)
+      diff = run_cmd('git log --oneline -1 --format=%H | xargs -I{} git diff {}~5..{} 2>/dev/null')
+      if diff.strip.empty?
+        record('Compressor: diff_hunks', true, 'SKIP — diff too small')
+        return 0
+      end
+      pass = compressor.compress('git_diff', diff).length <= diff.length
+      record('Compressor: diff_hunks', pass)
+      pass ? 1 : 0
+    end
+
+    # ── 7. Skills ───────────────────────────────────────────────────
+
+    def check_skills
+      catalog = Skills::Catalog.new(project_root)
+      skills = catalog.available
+      record('Skills catalog', skills.size >= 10, "#{skills.size} skills")
+    rescue StandardError => e
+      record('Skills', false, e.message)
+    end
+
+    # ── 8. Config ───────────────────────────────────────────────────
+
+    def check_config
+      config_path = File.expand_path('~/.rubyn-code/config.yml')
+      if File.exist?(config_path)
+        record('Config (config.yml)', File.read(config_path).include?('provider'))
+      else
+        record('Config (config.yml)', false, 'not found')
+      end
+
+      profile = File.join(project_root, '.rubyn-code/project_profile.yml')
+      record('Config (project_profile)', File.exist?(profile),
+             File.exist?(profile) ? 'exists' : 'SKIP — first session')
+    rescue StandardError => e
+      record('Config', false, e.message)
+    end
+
+    # ── 9. Codebase Index ───────────────────────────────────────────
+
+    def check_codebase_index
+      path = File.join(project_root, '.rubyn-code/codebase_index.json')
+      record('Codebase index', File.exist?(path),
+             File.exist?(path) ? 'exists' : 'SKIP — first session')
+    rescue StandardError => e
+      record('Codebase index', false, e.message)
+    end
+
+    # ── 10. Slash Commands ──────────────────────────────────────────
+
+    def check_slash_commands
+      cmd_dir = File.join(project_root, 'lib/rubyn_code/cli/commands')
+      infra = %w[base.rb context.rb registry.rb]
+      cmds = Dir.glob(File.join(cmd_dir, '*.rb')).reject { |f| infra.include?(File.basename(f)) }
+      record('Slash commands', cmds.size >= 15, "#{cmds.size} commands")
+    rescue StandardError => e
+      record('Slash commands', false, e.message)
+    end
+
+    # ── 11. Architecture ────────────────────────────────────────────
+
+    def check_architecture
+      check_autoloads
+      check_layer_dirs
+      check_core_modules
+    rescue StandardError => e
+      record('Architecture', false, e.message)
+    end
+
+    def check_autoloads
+      content = File.read(File.join(project_root, 'lib/rubyn_code.rb'))
+      autoloads = content.scan('autoload').size
+      record('Autoload entries', autoloads >= 40, "#{autoloads} entries")
+    end
+
+    def check_layer_dirs
+      dirs = Dir.glob(File.join(project_root, 'lib/rubyn_code/*/'))
+      record('Layer directories', dirs.size >= 14, "#{dirs.size} dirs")
+    end
+
+    def check_core_modules
+      content = File.read(File.join(project_root, 'lib/rubyn_code.rb'))
+      core = %w[Agent Tools Context Skills Memory Observability Learning]
+      found = core.select { |m| content.include?("module #{m}") }
+      record('Core modules', found.size == core.size, "#{found.size}/#{core.size}")
+    end
+
+    # ── Helpers ─────────────────────────────────────────────────────
+
+    def record(name, passed, detail = nil)
+      @results << Result.new(name: name, passed: passed, detail: detail)
+    end
+
+    def run_cmd(cmd)
+      `cd #{project_root} && #{cmd} 2>&1`.strip
+    end
+
+    def rb_files_with_def
+      Dir.glob(File.join(project_root, 'lib/**/*.rb')).flat_map do |f|
+        File.readlines(f).select { |l| l.include?('def ') }.map { |l| "#{f}:#{l.strip}" }
+      end
+    end
+
+    def print_scorecard
+      puts
+      puts 'Rubyn Self-Test Results'
+      puts '=' * 50
+      results.each_with_index { |r, i| print_result(r, i + 1) }
+      print_summary
+    end
+
+    def print_result(result, num)
+      icon = result.passed ? "\e[32m✅\e[0m" : "\e[31m❌\e[0m"
+      suffix = result.detail ? " — #{result.detail}" : ''
+      puts format(' %2<num>d. %<icon>s %<name>s%<suffix>s',
+                  num: num, icon: icon, name: result.name, suffix: suffix)
+    end
+
+    def print_summary
+      passed = results.count(&:passed)
+      total = results.size
+      pct = total.positive? ? (passed * 100.0 / total).round : 0
+      failed = total - passed
+
+      puts '=' * 50
+      if failed.zero?
+        puts "\e[32mScore: #{passed}/#{total} (#{pct}%) — All systems go!\e[0m"
+      else
+        puts "\e[33mScore: #{passed}/#{total} (#{pct}%) — #{failed} failures\e[0m"
+      end
+      puts
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end

data/lib/rubyn_code/skills/catalog.rb

@@ -24,11 +24,53 @@ module RubynCode
         @index
       end
 
+      def list
+        available.map { |e| e[:name] }
+      end
+
       def find(name)
         entry = available.find { |e| e[:name] == name.to_s }
         entry&.fetch(:path)
       end
 
+      # Search skill content — matches against names, descriptions, and tags.
+      # Returns matching entries sorted by relevance (number of field matches).
+      #
+      # @param term [String] search term (case-insensitive)
+      # @return [Array<Hash>] matching entries with :name, :description, :path, :relevance
+      def search(term)
+        pattern = /#{Regexp.escape(term)}/i
+        matches = available.filter_map do |entry|
+          relevance = compute_relevance(entry, pattern)
+          next if relevance.zero?
+
+          entry.merge(relevance: relevance)
+        end
+        matches.sort_by { |e| -e[:relevance] }
+      end
+
+      # Filter skills by category (subdirectory name).
+      # Skills are organized in subdirectories under each skills_dir.
+      #
+      # @param category [String] category/directory name (e.g. "rails", "testing")
+      # @return [Array<Hash>] matching entries
+      def by_category(category)
+        normalized = category.to_s.downcase
+        available.select do |entry|
+          path_category(entry[:path]).downcase == normalized
+        end
+      end
+
+      # Return the list of unique categories derived from skill file paths.
+      #
+      # @return [Array<String>] sorted category names
+      def categories
+        available.map { |e| path_category(e[:path]) }
+                 .reject(&:empty?)
+                 .uniq
+                 .sort
+      end
+
       private
 
       def build_index
@@ -60,11 +102,35 @@ module RubynCode
         {
           name: name,
           description: doc.description,
+          tags: doc.tags,
           path: File.expand_path(path)
         }
       rescue StandardError
         nil
       end
+
+      def compute_relevance(entry, pattern)
+        score = 0
+        score += 3 if entry[:name].to_s.match?(pattern)
+        score += 2 if entry[:description].to_s.match?(pattern)
+        Array(entry[:tags]).each { |tag| score += 1 if tag.to_s.match?(pattern) }
+        score
+      end
+
+      # Derive a category from the skill file path.
+      # The category is the immediate parent directory name relative to one of
+      # the skills_dirs. Skills at the top level of a skills_dir have no category.
+      def path_category(path)
+        skills_dirs.each do |dir|
+          expanded = File.expand_path(dir)
+          next unless path.start_with?(expanded)
+
+          relative = path.delete_prefix("#{expanded}/")
+          parts = relative.split('/')
+          return parts.size > 1 ? parts.first : ''
+        end
+        ''
+      end
     end
   end
 end

data/lib/rubyn_code/skills/loader.rb

@@ -33,6 +33,31 @@ module RubynCode
         catalog.descriptions
       end
 
+      # Suggest skills based on what the codebase index reveals about the project.
+      #
+      # Inspects class names, parent classes, and file paths in the index to
+      # detect common Rails patterns (Devise, ActionMailer, ActiveJob, etc.)
+      # and returns matching skill names.
+      #
+      # @param codebase_index [RubynCode::Index::CodebaseIndex, nil]
+      # @param project_profile [Object, nil] reserved for future profile-based hints
+      # @return [Array<String>] suggested skill names (not loaded automatically)
+      def suggest_skills(codebase_index: nil, project_profile: nil) # rubocop:disable Lint/UnusedMethodArgument, Metrics/CyclomaticComplexity -- project_profile reserved for future use
+        return [] unless codebase_index
+
+        suggestions = []
+        node_names = codebase_index.nodes.map { |n| n['name'].to_s }
+        node_files = codebase_index.nodes.map { |n| n['file'].to_s }
+
+        suggestions << 'authentication' if detect_devise?(node_names, node_files)
+        suggestions << 'mailer'         if detect_action_mailer?(node_names, node_files)
+        suggestions << 'background-job' if detect_active_job?(node_names, node_files)
+
+        suggestions
+      rescue StandardError
+        []
+      end
+
       private
 
       def format_skill(doc)
@@ -50,6 +75,24 @@ module RubynCode
             .gsub('>', '&gt;')
             .gsub('"', '&quot;')
       end
+
+      # Devise detection: look for Devise-related class names or config files.
+      def detect_devise?(node_names, node_files)
+        node_names.any? { |n| n.match?(/\bDevise\b/i) } ||
+          node_files.any? { |f| f.include?('devise') }
+      end
+
+      # ActionMailer detection: look for mailer classes or mailer directory.
+      def detect_action_mailer?(node_names, node_files)
+        node_names.any? { |n| n.match?(/Mailer\b/) } ||
+          node_files.any? { |f| f.include?('app/mailers/') }
+      end
+
+      # ActiveJob detection: look for job classes or jobs directory.
+      def detect_active_job?(node_names, node_files)
+        node_names.any? { |n| n.match?(/Job\b/) } ||
+          node_files.any? { |f| f.include?('app/jobs/') }
+      end
     end
   end
 end

data/lib/rubyn_code/tasks/models.rb

@@ -10,6 +10,7 @@ module RubynCode
       def in_progress? = status == 'in_progress'
       def completed? = status == 'completed'
       def blocked? = status == 'blocked'
+      def failed? = status == 'failed'
 
       def to_h
         {

data/lib/rubyn_code/tools/base.rb

@@ -37,6 +37,19 @@ module RubynCode
             input_schema: Schema.build(parameters)
           }
         end
+
+        # One-line summary of a successful invocation, shown in the IDE's
+        # chat card. Default is empty so the UI renders a clean "Done"
+        # indicator. Override in subclasses that have a useful one-liner
+        # (e.g. "Edited app.rb (1 replacement)"). The full output still
+        # goes to the conversation untouched — this only affects the UI.
+        #
+        # @param output [String] what execute(**) returned
+        # @param args   [Hash]   the tool arguments (string-keyed)
+        # @return [String]
+        def summarize(_output, _args)
+          ''
+        end
       end
 
       attr_reader :project_root

data/lib/rubyn_code/tools/bash.rb

@@ -18,6 +18,11 @@ module RubynCode
       RISK_LEVEL = :execute
       REQUIRES_CONFIRMATION = true
 
+      def self.summarize(_output, args)
+        cmd = args['command'] || args[:command] || ''
+        "$ #{cmd[0, 180]}"
+      end
+
       def execute(command:, timeout: 120)
         validate_command!(command)