rubyn-code 0.2.2 → 0.4.0

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

@@ -5,31 +5,118 @@ module RubynCode
     module Commands
       class Model < Base
         def self.command_name = '/model'
-        def self.description = 'Show or switch model (/model [name])'
-
-        KNOWN_MODELS = %w[
-          claude-haiku-4-5
-          claude-sonnet-4-20250514
-          claude-opus-4-20250514
-        ].freeze
+        def self.description = 'Show or switch model (/model [provider:model])'
 
         def execute(args, ctx)
           name = args.first
+          return show_current(ctx) unless name
+
+          provider, model = parse_model_arg(name)
+          switch_model(provider, model, ctx)
+        end
 
-          if name
-            unless KNOWN_MODELS.include?(name)
-              ctx.renderer.warning("Unknown model: #{name}")
-              ctx.renderer.info("Known models: #{KNOWN_MODELS.join(', ')}")
-              return
-            end
+        private
 
-            ctx.renderer.info("Model switched to #{name}")
-            { action: :set_model, model: name }
+        # Parse "provider:model" or just "model".
+        # Examples:
+        #   "openai:gpt-4o"            → ["openai", "gpt-4o"]
+        #   "claude-sonnet-4-20250514" → [nil, "claude-sonnet-4-20250514"]
+        #   "anthropic:"               → ["anthropic", nil]
+        def parse_model_arg(arg)
+          return [arg.chomp(':'), nil] if arg.end_with?(':')
+          return [Regexp.last_match(1), Regexp.last_match(2)] if arg.match(/\A([^:]+):(.+)\z/)
+
+          [nil, arg]
+        end
+
+        def switch_model(provider, model, ctx)
+          if provider
+            switch_provider_and_model(provider, model, ctx)
           else
-            current = Config::Defaults::DEFAULT_MODEL
-            ctx.renderer.info("Current model: #{current}")
-            ctx.renderer.info("Available: #{KNOWN_MODELS.join(', ')}")
+            switch_model_only(model, ctx)
+          end
+        end
+
+        def switch_provider_and_model(provider, model, ctx)
+          validate_model_for_provider!(provider, model, ctx) if model
+          ctx.renderer.info("Switched to provider: #{provider}#{", model: #{model}" if model}")
+          { action: :set_provider, provider: provider, model: model }
+        end
+
+        def switch_model_only(model, ctx)
+          unless known_model?(model, ctx)
+            ctx.renderer.warning("Unknown model: #{model}")
+            show_available(ctx)
+            return
           end
+
+          ctx.renderer.info("Model switched to #{model}")
+          { action: :set_model, model: model }
+        end
+
+        def validate_model_for_provider!(provider, model, ctx)
+          adapter_models = models_for_provider(provider)
+          return if adapter_models.empty? # Unknown provider — can't validate
+          return if adapter_models.include?(model)
+
+          ctx.renderer.warning("Unknown model '#{model}' for #{provider}. Known: #{adapter_models.join(', ')}")
+        end
+
+        def show_current(ctx)
+          client = ctx.llm_client
+          provider = client.provider_name
+          current = client.model
+          ctx.renderer.info("Provider: #{provider}")
+          ctx.renderer.info("Current model: #{current}")
+          ctx.renderer.info("Available: #{client.models.join(', ')}")
+          show_other_providers(provider, ctx)
+          ctx.renderer.info('Tip: /model provider:model to switch providers (e.g., /model openai:gpt-4o)')
+        end
+
+        def show_other_providers(current_provider, ctx)
+          others = other_provider_entries(current_provider)
+          return if others.empty?
+
+          ctx.renderer.info('')
+          ctx.renderer.info('Other providers:')
+          others.each { |label| ctx.renderer.info("  #{label}") }
+        end
+
+        def other_provider_entries(current_provider)
+          providers = Config::Settings.new.data['providers']
+          return [] unless providers.is_a?(Hash)
+
+          providers.reject { |name, _| name == current_provider }.map do |name, cfg|
+            models = extract_config_models(cfg)
+            models.empty? ? name : "#{name}: #{models.join(', ')}"
+          end
+        end
+
+        def show_available(ctx)
+          client = ctx.llm_client
+          ctx.renderer.info("Available: #{client.models.join(', ')}")
+          ctx.renderer.info('Tip: /model provider:model to switch providers (e.g., /model openai:gpt-4o)')
+        end
+
+        def known_model?(model, ctx)
+          ctx.llm_client.models.include?(model)
+        end
+
+        def models_for_provider(provider)
+          case provider
+          when 'anthropic' then LLM::Adapters::Anthropic::AVAILABLE_MODELS
+          when 'openai' then LLM::Adapters::OpenAI::AVAILABLE_MODELS
+          else
+            cfg = Config::Settings.new.provider_config(provider)
+            extract_config_models(cfg)
+          end
+        end
+
+        def extract_config_models(cfg)
+          raw = cfg&.dig('models')
+          return [] unless raw
+
+          raw.is_a?(Hash) ? raw.values : Array(raw)
         end
       end
     end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      # Saves the current session and starts a fresh conversation.
+      # Like pressing Escape in Claude Code — clears context without quitting.
+      class NewSession < Base
+        def self.command_name = '/new'
+        def self.description = 'Save current session and start a fresh conversation'
+        def self.aliases = ['/reset'].freeze
+
+        def execute(_args, ctx)
+          save_current_session(ctx)
+          clear_conversation(ctx)
+          new_session_id = generate_session_id
+
+          ctx.renderer.info('Session saved. Starting fresh.')
+          ctx.renderer.info("New session: #{new_session_id[0..7]}")
+
+          { action: :new_session, session_id: new_session_id }
+        end
+
+        private
+
+        def save_current_session(ctx)
+          ctx.session_persistence.save_session(
+            session_id: ctx.session_id,
+            project_path: ctx.project_root,
+            messages: ctx.conversation.messages,
+            model: Config::Defaults::DEFAULT_MODEL
+          )
+        end
+
+        def clear_conversation(ctx)
+          ctx.conversation.clear!
+        end
+
+        def generate_session_id
+          SecureRandom.hex(16)
+        end
+      end
+    end
+  end
+end

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

@@ -18,14 +18,9 @@ module RubynCode
       end
 
       def run
-        ensure_home_dir!
-        ensure_auth!
-        setup_database!
-        display_banner!
-
+        bootstrap!
         daemon = build_daemon
         daemon.start!
-
         display_shutdown_summary(daemon)
       rescue Interrupt
         @renderer.info("\nShutting down daemon...")
@@ -34,10 +29,20 @@ 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
 
+      def bootstrap!
+        ensure_home_dir!
+        ensure_auth!
+        setup_database!
+        setup_mcp_servers!
+        display_banner!
+      end
+
       def build_daemon
         Autonomous::Daemon.new(
           agent_name: @daemon_opts[:agent_name],
@@ -79,13 +84,16 @@ module RubynCode
       end
 
       def ensure_auth!
-        unless Auth::TokenStore.valid?
-          @renderer.error('No valid authentication found.')
-          @renderer.info('Run `rubyn-code --auth` or set ANTHROPIC_API_KEY first.')
+        provider = @daemon_opts.fetch(:provider, Config::Defaults::DEFAULT_PROVIDER)
+
+        unless Auth::TokenStore.load_for_provider(provider)
+          @renderer.error("No valid authentication found for provider '#{provider}'.")
+          env_key = Config::Defaults::PROVIDER_ENV_KEYS.fetch(provider, "#{provider.upcase}_API_KEY")
+          @renderer.info("Set #{env_key} or run `rubyn-code --auth`.")
           exit(1)
         end
 
-        @llm_client = LLM::Client.new
+        @llm_client = LLM::Client.new(provider: provider)
       end
 
       def setup_database!
@@ -96,9 +104,18 @@ module RubynCode
       end
 
       def display_banner!
+        display_banner_header!
+        display_banner_details!
+        display_banner_footer!
+      end
+
+      def display_banner_header!
         @renderer.info('╔══════════════════════════════════════╗')
         @renderer.info('║        GOLEM Daemon Starting         ║')
         @renderer.info('╚══════════════════════════════════════╝')
+      end
+
+      def display_banner_details!
         @renderer.info("  Agent:        #{@daemon_opts[:agent_name]}")
         @renderer.info("  Role:         #{@daemon_opts[:role]}")
         @renderer.info("  Project:      #{@project_root}")
@@ -106,6 +123,9 @@ module RubynCode
         @renderer.info("  Max cost:     $#{@daemon_opts[:max_cost]}")
         @renderer.info("  Idle timeout: #{@daemon_opts[:idle_timeout]}s")
         @renderer.info("  Poll interval: #{@daemon_opts[:poll_interval]}s")
+      end
+
+      def display_banner_footer!
         @renderer.info('')
         @renderer.info('Waiting for tasks... (Ctrl-C to stop)')
         @renderer.info('Seed tasks via the REPL: /tasks or the task tool.')
@@ -122,7 +142,40 @@ module RubynCode
         @renderer.info('╚══════════════════════════════════════╝')
         @renderer.info("  Final state:    #{status[:state]}")
         @renderer.info("  Tasks completed: #{status[:runs_completed]}")
-        @renderer.info("  Total cost:     $#{'%.4f' % status[:total_cost]}")
+        @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

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