rubyn-code 0.3.0 → 0.5.0

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/llm/model_router.rb

@@ -84,7 +84,8 @@ module RubynCode
         # @param task_type [Symbol]
         # @param client [LLM::Client, nil] active client (for provider checks)
         # @return [Hash] { provider:, model: }
-        def resolve(task_type, client: nil) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity -- multi-source fallback chain
+        # -- multi-source fallback chain
+        def resolve(task_type, client: nil)
           tier = tier_for(task_type)
           active = active_provider
 

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/mcp/tool_bridge.rb

@@ -51,7 +51,7 @@ module RubynCode
           klass
         end
 
-        def create_tool_class(tool_name, description, parameters, mcp_client, remote_name) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- dynamic class creation requires setting many constants
+        def create_tool_class(tool_name, description, parameters, mcp_client, remote_name) # rubocop:disable Metrics/MethodLength -- dynamic class creation requires setting many constants
           bridge = self
 
           Class.new(Tools::Base) do

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/observability/usage_reporter.rb

@@ -80,7 +80,8 @@ module RubynCode
         }
       end
 
-      def build_session_summary_lines(session_id, turns, totals) # rubocop:disable Metrics/AbcSize -- assembles multi-field summary
+      # -- assembles multi-field summary
+      def build_session_summary_lines(session_id, turns, totals)
         avg_cost = turns.positive? ? totals[:cost] / turns : 0.0
         [
           header('Session Summary'),
@@ -104,7 +105,8 @@ module RubynCode
         ).to_a
       end
 
-      def build_daily_summary_lines(today, rows) # rubocop:disable Metrics/AbcSize -- assembles multi-field daily summary
+      # -- assembles multi-field daily summary
+      def build_daily_summary_lines(today, rows)
         total_input  = rows.sum { |r| fetch_int(r, 'input_tokens') }
         total_output = rows.sum { |r| fetch_int(r, 'output_tokens') }
         total_cost   = rows.sum { |r| fetch_float(r, 'cost_usd') }

data/lib/rubyn_code/output/diff_renderer.rb

@@ -97,7 +97,8 @@ module RubynCode
         table
       end
 
-      def fill_lcs_row(table, row, old_lines, new_lines, col_count) # rubocop:disable Metrics/AbcSize -- LCS algorithm step
+      # -- LCS algorithm step
+      def fill_lcs_row(table, row, old_lines, new_lines, col_count)
         (1..col_count).each do |col|
           table[row][col] = if old_lines[row - 1] == new_lines[col - 1]
                               table[row - 1][col - 1] + 1
@@ -121,7 +122,7 @@ module RubynCode
         result
       end
 
-      def backtrack_step(result, table, old_lines, new_lines, old_idx, new_idx) # rubocop:disable Metrics/AbcSize, Metrics/ParameterLists -- LCS backtrack step requires all state
+      def backtrack_step(result, table, old_lines, new_lines, old_idx, new_idx) # rubocop:disable Metrics/ParameterLists -- LCS backtrack step requires all state
         if lines_match?(old_lines, new_lines, old_idx, new_idx)
           result.unshift([:equal, old_idx - 1, new_idx - 1])
           [old_idx - 1, new_idx - 1]

data/lib/rubyn_code/self_test.rb

@@ -0,0 +1,316 @@
+# 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
+
+    # -- sequential file ops
+    def check_file_write_edit_cleanup
+      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/auto_suggest.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'gemfile_parser'
+
+module RubynCode
+  module Skills
+    # Suggests skill packs based on gems detected in the project's Gemfile.
+    #
+    # On session start, parses the Gemfile, queries the registry for matching
+    # packs, and shows a one-time suggestion. Tracks shown suggestions in
+    # `.rubyn-code/suggested.json` to avoid repeating.
+    class AutoSuggest
+      SUGGESTED_FILE = 'suggested.json'
+
+      # @param project_root [String]
+      # @param registry_client [RegistryClient]
+      def initialize(project_root:, registry_client: nil)
+        @project_root = project_root
+        @client = registry_client || RegistryClient.new
+      end
+
+      # Check for suggestable packs and return a display message if any.
+      # Returns nil if no suggestions or if all have been shown/dismissed.
+      #
+      # This method never raises — registry failures are silently swallowed
+      # to avoid blocking session start.
+      #
+      # @return [String, nil] suggestion message or nil
+      def check
+        gems = parse_gemfile
+        return nil if gems.empty?
+
+        suggestions = fetch_suggestions(gems)
+        return nil if suggestions.empty?
+
+        new_suggestions = filter_shown(suggestions)
+        return nil if new_suggestions.empty?
+
+        record_shown(new_suggestions)
+        format_message(new_suggestions)
+      rescue StandardError
+        nil
+      end
+
+      # Mark a pack as installed so it won't be suggested again.
+      #
+      # @param name [String] pack name
+      def mark_installed(name)
+        state = load_state
+        state['installed'] ||= []
+        state['installed'] << name unless state['installed'].include?(name)
+        save_state(state)
+      end
+
+      # Mark a suggestion as dismissed.
+      #
+      # @param name [String] pack name
+      def mark_dismissed(name)
+        state = load_state
+        state['dismissed'] ||= []
+        state['dismissed'] << name unless state['dismissed'].include?(name)
+        save_state(state)
+      end
+
+      private
+
+      def parse_gemfile
+        gemfile_path = File.join(@project_root, 'Gemfile')
+        return [] unless File.exist?(gemfile_path)
+
+        GemfileParser.gems(File.read(gemfile_path))
+      rescue StandardError
+        []
+      end
+
+      def fetch_suggestions(gems)
+        @client.fetch_suggestions(gems)
+      rescue RegistryError
+        []
+      end
+
+      def filter_shown(suggestions)
+        state = load_state
+        shown = Array(state['shown'])
+        installed = Array(state['installed'])
+        dismissed = Array(state['dismissed'])
+        skip = (shown + installed + dismissed).uniq
+
+        suggestions.reject { |s| skip.include?(s['name']) }
+      end
+
+      def record_shown(suggestions)
+        state = load_state
+        state['shown'] ||= []
+        suggestions.each do |s|
+          state['shown'] << s['name'] unless state['shown'].include?(s['name'])
+        end
+        save_state(state)
+      end
+
+      def format_message(suggestions)
+        gem_names = suggestions.map { |s| s['name'] }.join(', ')
+        details = suggestions.map { |s| "#{s['name']} (#{s['reason']})" }.join(', ')
+        install_cmd = "/install-skills #{suggestions.map { |s| s['name'] }.join(' ')}"
+
+        "Skill packs available: #{details}\n" \
+          "Run #{install_cmd} to install."
+      end
+
+      def load_state
+        path = state_path
+        return {} unless File.exist?(path)
+
+        JSON.parse(File.read(path))
+      rescue JSON::ParserError
+        {}
+      end
+
+      def save_state(state)
+        dir = File.dirname(state_path)
+        FileUtils.mkdir_p(dir)
+        File.write(state_path, JSON.pretty_generate(state))
+      end
+
+      def state_path
+        File.join(@project_root, '.rubyn-code', SUGGESTED_FILE)
+      end
+    end
+  end
+end

data/lib/rubyn_code/skills/catalog.rb

@@ -24,11 +24,60 @@ module RubynCode
         @index
       end
 
+      # Force the index to be rebuilt on next access. Used after installing
+      # a skill pack so newly-written files become discoverable in the same
+      # session.
+      def refresh!
+        @index = nil
+      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 +109,38 @@ module RubynCode
         {
           name: name,
           description: doc.description,
+          tags: doc.tags,
+          triggers: doc.triggers,
+          gems: doc.gems,
+          rails: doc.rails,
           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