rubyn-code 0.3.0 → 0.4.0

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class Provider < Base
+        def self.command_name = '/provider'
+        def self.description = 'Manage providers (/provider add|list|set-key)'
+
+        USAGE_LINES = [
+          'Usage:',
+          '  /provider list                            List configured providers',
+          '  /provider add <name> <base_url> [opts]    Add a provider',
+          '  /provider set-key <name> <key>            Store an API key',
+          '',
+          'Options for add:',
+          '  --key <api_key>              API key (stored securely in tokens.yml)',
+          '  --format <openai|anthropic>  API format (default: openai)',
+          '  --models <m1,m2,...>          Comma-separated model names',
+          '',
+          'Example:',
+          '  /provider add groq https://api.groq.com/openai/v1 --key gsk-xxx --models llama-3.3-70b'
+        ].freeze
+
+        FLAG_KEYS = { '--format' => :api_format, '--env-key' => :env_key, '--key' => :key }.freeze
+
+        def execute(args, ctx)
+          return show_usage(ctx) if args.empty?
+
+          case args.first
+          when 'add' then add_provider(args[1..], ctx)
+          when 'list' then list_providers(ctx)
+          when 'set-key' then set_key(args[1..], ctx)
+          else show_usage(ctx)
+          end
+        end
+
+        private
+
+        def add_provider(args, ctx)
+          name = args.shift
+          base_url = args.shift
+          return ctx.renderer.warning('Usage: /provider add <name> <base_url> [options]') unless name && base_url
+
+          opts = parse_flags(args)
+          persist_provider(name, base_url, opts)
+          confirm_added(name, base_url, opts, ctx)
+        end
+
+        def persist_provider(name, base_url, opts)
+          Config::Settings.new.add_provider(
+            name, base_url: base_url, env_key: opts[:env_key],
+                  models: opts[:models], api_format: opts[:api_format]
+          )
+          Auth::TokenStore.save_provider_key(name, opts[:key]) if opts[:key]
+        end
+
+        def confirm_added(name, base_url, opts, ctx) # rubocop:disable Metrics/AbcSize -- sequential output lines
+          ctx.renderer.success("Provider '#{name}' added (#{opts[:api_format] || 'openai'} format)")
+          ctx.renderer.info("  base_url: #{base_url}")
+          ctx.renderer.info('  api_key: stored') if opts[:key]
+          ctx.renderer.info("  models: #{opts[:models].join(', ')}") unless opts[:models].empty?
+          ctx.renderer.info("Switch with: /model #{name}:#{opts[:models].first || '<model>'}")
+        end
+
+        def set_key(args, ctx)
+          name = args[0]
+          key = args[1]
+          return ctx.renderer.warning('Usage: /provider set-key <name> <key>') unless name && key
+
+          Auth::TokenStore.save_provider_key(name, key)
+          ctx.renderer.success("API key stored for '#{name}'")
+        end
+
+        def list_providers(ctx)
+          providers = Config::Settings.new.data['providers']
+          return ctx.renderer.info('No providers configured.') unless providers.is_a?(Hash) && providers.any?
+
+          providers.each { |name, cfg| ctx.renderer.info("  #{format_provider(name, cfg)}") }
+        end
+
+        def format_provider(name, cfg)
+          format_label = cfg.is_a?(Hash) && cfg['api_format'] ? " (#{cfg['api_format']})" : ''
+          models = extract_models(cfg)
+          model_label = models.empty? ? '' : " — #{models.join(', ')}"
+          "#{name}#{format_label}#{model_label}"
+        end
+
+        def parse_flags(args)
+          opts = { models: [], env_key: nil, api_format: nil, key: nil }
+          idx = 0
+          idx = parse_single_flag(args, idx, opts) while idx < args.length
+          opts
+        end
+
+        def parse_single_flag(args, idx, opts)
+          flag = args[idx]
+          return idx + 1 unless FLAG_KEYS.key?(flag) || flag == '--models'
+          return parse_models_flag(args, idx, opts) if flag == '--models'
+
+          opts[FLAG_KEYS[flag]] = args[idx + 1]
+          idx + 2
+        end
+
+        def parse_models_flag(args, idx, opts)
+          opts[:models] = args[idx + 1]&.split(',')&.map(&:strip) || []
+          idx + 2
+        end
+
+        def extract_models(cfg)
+          raw = cfg.is_a?(Hash) ? cfg['models'] : nil
+          return [] unless raw
+
+          raw.is_a?(Hash) ? raw.values : Array(raw)
+        end
+
+        def show_usage(ctx)
+          USAGE_LINES.each { |line| ctx.renderer.info(line) }
+        end
+      end
+    end
+  end
+end

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

@@ -8,7 +8,13 @@ module RubynCode
         def self.description = 'Load a skill or list available skills'
 
         def execute(args, ctx)
-          args.first ? load_skill(args.first, ctx) : list_skills(ctx)
+          return list_skills(ctx) if args.empty?
+
+          case args.first
+          when 'search' then search_skills(args[1..].join(' '), ctx)
+          when 'list'   then list_by_category(args[1], ctx)
+          else               load_skill(args.first, ctx)
+          end
         rescue StandardError => e
           ctx.renderer.error("Skill error: #{e.message}")
         end
@@ -22,9 +28,52 @@ module RubynCode
         end
 
         def list_skills(ctx)
-          skills = ctx.skill_loader.catalog.list
+          skills = ctx.skill_loader.catalog.available
           ctx.renderer.info("Available skills (#{skills.size}):")
-          skills.each { |skill| puts "  /#{skill}" }
+          skills.each { |skill| puts "  /#{skill[:name]}: #{skill[:description]}" }
+        end
+
+        def search_skills(term, ctx) # rubocop:disable Metrics/AbcSize -- readable sequential display logic
+          if term.nil? || term.strip.empty?
+            ctx.renderer.warning('Usage: /skill search <term>')
+            return
+          end
+
+          results = ctx.skill_loader.catalog.search(term.strip)
+          if results.empty?
+            ctx.renderer.info("No skills found matching '#{term.strip}'")
+            return
+          end
+
+          ctx.renderer.info("Skills matching '#{term.strip}' (#{results.size}):")
+          display_entries(results)
+        end
+
+        def list_by_category(category, ctx) # rubocop:disable Metrics/AbcSize -- readable sequential display logic
+          catalog = ctx.skill_loader.catalog
+          return list_categories(catalog, ctx) if category.nil? || category.strip.empty?
+
+          results = catalog.by_category(category.strip)
+          if results.empty?
+            ctx.renderer.info("No skills found in category '#{category.strip}'")
+            return
+          end
+
+          ctx.renderer.info("Skills in '#{category.strip}' (#{results.size}):")
+          display_entries(results)
+        end
+
+        def list_categories(catalog, ctx)
+          categories = catalog.categories
+          ctx.renderer.info("Skill categories (#{categories.size}):")
+          categories.each { |cat| puts "  #{cat}" }
+        end
+
+        def display_entries(entries)
+          entries.each do |entry|
+            desc = entry[:description].to_s.empty? ? '' : " — #{entry[:description]}"
+            puts "  /#{entry[:name]}#{desc}"
+          end
         end
       end
     end

data/lib/rubyn_code/cli/daemon_runner.rb

@@ -29,6 +29,8 @@ module RubynCode
         @renderer.error("Daemon failed: #{e.message}")
         RubynCode::Debug.warn(e.backtrace&.first(5)&.join("\n")) if @options[:debug]
         exit(1)
+      ensure
+        disconnect_mcp_clients!
       end
 
       private
@@ -37,6 +39,7 @@ module RubynCode
         ensure_home_dir!
         ensure_auth!
         setup_database!
+        setup_mcp_servers!
         display_banner!
       end
 
@@ -141,6 +144,39 @@ module RubynCode
         @renderer.info("  Tasks completed: #{status[:runs_completed]}")
         @renderer.info(format('  Total cost:     $%.4f', status[:total_cost]))
       end
+
+      # ── MCP Server Wiring ─────────────────────────────────────────
+
+      def setup_mcp_servers!
+        @mcp_clients = []
+        server_configs = MCP::Config.load(@project_root)
+        return if server_configs.empty?
+
+        server_configs.each do |config|
+          connect_mcp_server(config)
+        end
+      end
+
+      def connect_mcp_server(config)
+        client = MCP::Client.from_config(config)
+        client.connect!
+        MCP::ToolBridge.bridge(client)
+        @mcp_clients << client
+        @renderer.info("  MCP server '#{config[:name]}' connected (#{client.tools.size} tools)")
+      rescue StandardError => e
+        warn "[MCP] Failed to connect '#{config[:name]}': #{e.message}"
+      end
+
+      def disconnect_mcp_clients!
+        return if @mcp_clients.nil? || @mcp_clients.empty?
+
+        @mcp_clients.each do |client|
+          client.disconnect!
+        rescue StandardError => e
+          warn "[MCP] Error disconnecting '#{client.name}': #{e.message}"
+        end
+        @mcp_clients.clear
+      end
     end
   end
 end

data/lib/rubyn_code/cli/first_run.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require 'tty-prompt'
+require 'yaml'
+require 'fileutils'
+
+module RubynCode
+  module CLI
+    # Guided first-run setup wizard.
+    #
+    # Runs when no ~/.rubyn-code/config.yml exists (first launch).
+    # Walks the user through provider selection, API key configuration,
+    # and default budget setup.
+    #
+    # Skippable via --skip-setup flag or RUBYN_SKIP_SETUP=1 env var.
+    class FirstRun
+      PROVIDERS = {
+        'Anthropic (recommended)' => 'anthropic',
+        'OpenAI' => 'openai',
+        'Other (configure later)' => 'other'
+      }.freeze
+
+      DEFAULT_BUDGET = 5.0
+
+      def initialize(config_path: Config::Defaults::CONFIG_FILE, prompt: nil)
+        @config_path = config_path
+        @tty_prompt = prompt
+      end
+
+      # Returns true if first-run setup should be triggered.
+      def self.needed?(config_path: Config::Defaults::CONFIG_FILE)
+        !File.exist?(config_path)
+      end
+
+      # Returns true if the user opted to skip setup.
+      def self.skipped?(skip_flag: false)
+        skip_flag || ENV['RUBYN_SKIP_SETUP'] == '1'
+      end
+
+      def run
+        display_welcome
+        provider = ask_provider
+        configure_api_key(provider)
+        budget = ask_budget
+        write_config(provider, budget)
+        display_summary
+      end
+
+      private
+
+      def tty_prompt
+        @tty_prompt ||= TTY::Prompt.new
+      end
+
+      def display_welcome
+        puts
+        puts "\e[1;36m#{'=' * 50}\e[0m"
+        puts "\e[1;36m  Welcome to Rubyn Code!\e[0m"
+        puts "\e[1;36m  Ruby & Rails Agentic Coding Assistant\e[0m"
+        puts "\e[1;36m#{'=' * 50}\e[0m"
+        puts
+        puts "  Let's get you set up. This will only take a moment."
+        puts
+      end
+
+      def ask_provider
+        tty_prompt.select('Which AI provider would you like to use?', PROVIDERS)
+      end
+
+      def configure_api_key(provider)
+        case provider
+        when 'anthropic'
+          configure_anthropic
+        when 'openai'
+          configure_openai
+        when 'other'
+          puts
+          puts '  You can configure a custom provider later in ~/.rubyn-code/config.yml'
+          puts
+        end
+      end
+
+      def configure_anthropic
+        puts
+        puts '  Anthropic authentication options:'
+        puts '    1. Set ANTHROPIC_API_KEY environment variable'
+        puts '    2. Run `rubyn-code --auth` for OAuth (if you have a Claude account)'
+        puts
+
+        has_key = ENV.key?('ANTHROPIC_API_KEY')
+        if has_key
+          puts "  \e[32m✓\e[0m ANTHROPIC_API_KEY is already set."
+        else
+          puts "  \e[33m!\e[0m ANTHROPIC_API_KEY is not set."
+          puts '    Add it to your shell profile or set it before running rubyn-code.'
+        end
+        puts
+      end
+
+      def configure_openai
+        puts
+        has_key = ENV.key?('OPENAI_API_KEY')
+        if has_key
+          puts "  \e[32m✓\e[0m OPENAI_API_KEY is already set."
+        else
+          puts "  \e[33m!\e[0m OPENAI_API_KEY is not set."
+          puts '    Add it to your shell profile or set it before running rubyn-code.'
+        end
+        puts
+      end
+
+      def ask_budget
+        tty_prompt.ask(
+          'Session budget in USD?',
+          default: DEFAULT_BUDGET.to_s,
+          convert: :float
+        )
+      end
+
+      def write_config(provider, budget)
+        dir = File.dirname(@config_path)
+        FileUtils.mkdir_p(dir, mode: 0o700) unless File.directory?(dir)
+
+        model = default_model(provider)
+        data = {
+          'provider' => provider == 'other' ? 'anthropic' : provider,
+          'model' => model,
+          'session_budget_usd' => budget,
+          'providers' => Config::Settings::DEFAULT_PROVIDER_MODELS.transform_values(&:dup)
+        }
+
+        File.write(@config_path, YAML.dump(data))
+        File.chmod(0o600, @config_path)
+      end
+
+      def default_model(provider)
+        return 'gpt-5.4' if provider == 'openai'
+
+        'claude-opus-4-6'
+      end
+
+      def display_summary
+        puts
+        puts "\e[1;32m  Setup complete!\e[0m"
+        puts
+        puts '  Quick-start commands:'
+        puts '    /help          — Show all available commands'
+        puts '    /skill         — List coding skills'
+        puts '    /doctor        — Check environment health'
+        puts '    /cost          — View session costs'
+        puts '    /compact       — Compress conversation context'
+        puts '    /quit          — Exit'
+        puts
+        puts "  Config saved to: #{@config_path}"
+        puts
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/repl.rb

@@ -98,7 +98,7 @@ module RubynCode
         @stream_formatter&.feed(text)
       end
 
-      def handle_message(input)
+      def handle_message(input) # rubocop:disable Metrics/AbcSize -- sequential steps with interrupt rescue
         @spinner.start
         @streaming_first_chunk = true
 
@@ -113,6 +113,11 @@ module RubynCode
           puts
         end
 
+        save_session!
+      rescue Interrupt
+        @spinner.stop
+        puts
+        @renderer.warning('Interrupted — session state preserved')
         save_session!
       rescue BudgetExceededError => e
         @spinner.error

data/lib/rubyn_code/cli/repl_commands.rb

@@ -21,7 +21,8 @@ module RubynCode
           Commands::Version, Commands::Review, Commands::Resume,
           Commands::Spawn, Commands::Doctor, Commands::Tokens,
           Commands::Plan, Commands::ContextInfo, Commands::Diff,
-          Commands::Model, Commands::NewSession
+          Commands::Model, Commands::NewSession, Commands::Mcp,
+          Commands::Provider
         ].each { |cmd| @command_registry.register(cmd) }
       end
 

data/lib/rubyn_code/cli/repl_lifecycle.rb

@@ -48,6 +48,7 @@ module RubynCode
         @renderer.info('Saving session...')
         save_session!
         @background_worker&.shutdown!
+        disconnect_mcp_clients!
         extract_learnings_if_needed
         decay_instincts
         @renderer.info("Session saved. Rubyn out. \u270C\uFE0F")

data/lib/rubyn_code/cli/repl_setup.rb

@@ -11,6 +11,7 @@ module RubynCode
         setup_services!
         setup_executor_callbacks!
         setup_hooks!
+        setup_mcp_servers!
         setup_agent_loop!
       end
 
@@ -140,6 +141,41 @@ module RubynCode
         dirs << user_skills if Dir.exist?(user_skills)
         dirs
       end
+
+      # ── MCP Server Wiring ─────────────────────────────────────────
+
+      def setup_mcp_servers!
+        @mcp_clients = []
+        server_configs = MCP::Config.load(@project_root)
+        return if server_configs.empty?
+
+        server_configs.each do |config|
+          connect_mcp_server(config)
+        end
+
+        at_exit { disconnect_mcp_clients! unless defined?(RSpec) }
+      end
+
+      def connect_mcp_server(config)
+        client = MCP::Client.from_config(config)
+        client.connect!
+        MCP::ToolBridge.bridge(client)
+        @mcp_clients << client
+        @renderer.info("MCP server '#{config[:name]}' connected (#{client.tools.size} tools)")
+      rescue StandardError => e
+        warn "[MCP] Failed to connect '#{config[:name]}': #{e.message}"
+      end
+
+      def disconnect_mcp_clients!
+        return if @mcp_clients.nil? || @mcp_clients.empty?
+
+        @mcp_clients.each do |client|
+          client.disconnect!
+        rescue StandardError => e
+          warn "[MCP] Error disconnecting '#{client.name}': #{e.message}"
+        end
+        @mcp_clients.clear
+      end
     end
   end
 end

data/lib/rubyn_code/config/defaults.rb

@@ -12,6 +12,7 @@ module RubynCode
 
       DEFAULT_PROVIDER = 'anthropic'
       DEFAULT_MODEL = 'claude-opus-4-6'
+      MODEL_MODE = 'auto' # 'auto' or 'manual'
       MAX_ITERATIONS = 200
       MAX_SUB_AGENT_ITERATIONS = 200
       MAX_EXPLORE_AGENT_ITERATIONS = 200

data/lib/rubyn_code/config/schema.json

@@ -0,0 +1,49 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "provider": {
+      "type": "string",
+      "minLength": 1
+    },
+    "model": {
+      "type": "string",
+      "minLength": 1
+    },
+    "model_mode": {
+      "type": "string",
+      "enum": ["auto", "manual"]
+    },
+    "max_iterations": {
+      "type": "integer",
+      "minimum": 1,
+      "maximum": 1000
+    },
+    "max_sub_agent_iterations": {
+      "type": "integer",
+      "minimum": 1,
+      "maximum": 500
+    },
+    "max_output_chars": {
+      "type": "integer",
+      "minimum": 1000,
+      "maximum": 1000000
+    },
+    "context_threshold_tokens": {
+      "type": "integer",
+      "minimum": 10000,
+      "maximum": 200000
+    },
+    "session_budget_usd": {
+      "type": "number",
+      "minimum": 0.1,
+      "maximum": 100
+    },
+    "daily_budget_usd": {
+      "type": "number",
+      "minimum": 0.5,
+      "maximum": 500
+    }
+  },
+  "additionalProperties": true
+}

data/lib/rubyn_code/config/settings.rb

@@ -10,7 +10,7 @@ module RubynCode
       class LoadError < StandardError; end
 
       CONFIGURABLE_KEYS = %i[
-        provider model max_iterations max_sub_agent_iterations max_output_chars
+        provider model model_mode max_iterations max_sub_agent_iterations max_output_chars
         context_threshold_tokens micro_compact_keep_recent
         poll_interval idle_timeout
         session_budget_usd daily_budget_usd
@@ -21,6 +21,7 @@ module RubynCode
       DEFAULT_MAP = {
         provider: Defaults::DEFAULT_PROVIDER,
         model: Defaults::DEFAULT_MODEL,
+        model_mode: Defaults::MODEL_MODE,
         max_iterations: Defaults::MAX_ITERATIONS,
         max_sub_agent_iterations: Defaults::MAX_SUB_AGENT_ITERATIONS,
         max_output_chars: Defaults::MAX_OUTPUT_CHARS,
@@ -114,10 +115,11 @@ module RubynCode
       # @param env_key [String, nil] environment variable for the API key
       # @param models [Array<String>] available model names
       # @param pricing [Hash] model => [input_rate, output_rate]
-      def add_provider(name, base_url:, env_key: nil, models: [], pricing: {})
+      # @param api_format [String, nil] API format ('openai' or 'anthropic')
+      def add_provider(name, base_url:, env_key: nil, models: [], pricing: {}, api_format: nil) # rubocop:disable Metrics/ParameterLists -- all optional kwargs with defaults
         @data['providers'] ||= {}
         @data['providers'][name.to_s] = build_provider_hash(
-          base_url: base_url, env_key: env_key, models: models, pricing: pricing
+          base_url: base_url, env_key: env_key, models: models, pricing: pricing, api_format: api_format
         )
         save!
       end
@@ -176,8 +178,9 @@ module RubynCode
         nil
       end
 
-      def build_provider_hash(base_url:, env_key:, models:, pricing:)
+      def build_provider_hash(base_url:, env_key:, models:, pricing:, api_format: nil)
         hash = { 'base_url' => base_url }
+        hash['api_format'] = api_format if api_format
         hash['env_key'] = env_key if env_key
         hash['models'] = models unless models.empty?
         hash['pricing'] = pricing unless pricing.empty?

data/lib/rubyn_code/config/validator.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'json_schemer'
+
+module RubynCode
+  module Config
+    class Validator
+      SCHEMA_PATH = File.expand_path('schema.json', __dir__)
+
+      def initialize
+        @raw_schema = JSON.parse(File.read(SCHEMA_PATH))
+        @schemer = JSONSchemer.schema(@raw_schema)
+      end
+
+      # Validates a single config key/value pair against the schema.
+      #
+      # @param key [String] the config key
+      # @param value [Object] the value to validate
+      # @return [Hash] { valid: true/false, errors: [String] }
+      def validate(key, value)
+        # If the key has no schema definition, accept any value
+        properties = @raw_schema.fetch('properties', {})
+        unless properties.key?(key.to_s)
+          return { valid: true, errors: [] }
+        end
+
+        doc = { key.to_s => value }
+        errors = @schemer.validate(doc).select { |e| e['data_pointer'] == "/#{key}" }
+
+        if errors.empty?
+          { valid: true, errors: [] }
+        else
+          messages = errors.map { |e| format_error(key, e) }
+          { valid: false, errors: messages }
+        end
+      end
+
+      private
+
+      def format_error(key, error)
+        detail = error['type']
+        schema_node = error.fetch('schema', {})
+
+        parts = ["#{key}: invalid value"]
+        parts << "(expected #{detail})" if detail
+
+        if schema_node.key?('minimum') || schema_node.key?('maximum')
+          range_parts = []
+          range_parts << "min #{schema_node['minimum']}" if schema_node.key?('minimum')
+          range_parts << "max #{schema_node['maximum']}" if schema_node.key?('maximum')
+          parts << "[#{range_parts.join(', ')}]"
+        end
+
+        if schema_node.key?('enum')
+          parts << "allowed: #{schema_node['enum'].join(', ')}"
+        end
+
+        parts.join(' ')
+      end
+    end
+  end
+end