rubyn-code 0.3.0 → 0.5.0

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

@@ -0,0 +1,124 @@
+# 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
+
+        # -- sequential output lines
+        def confirm_added(name, base_url, opts, ctx)
+          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/remove_skills.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class RemoveSkills < Base
+        def self.command_name = '/remove-skills'
+        def self.description = 'Remove installed skill packs'
+
+        def execute(args, ctx)
+          if args.empty?
+            ctx.renderer.warning('Usage: /remove-skills <pack-name> [pack-name ...]')
+            return
+          end
+
+          pack_manager = RubynCode::Skills::PackManager.new
+
+          args.each { |name| remove_pack(name, pack_manager, ctx) }
+        end
+
+        private
+
+        def remove_pack(name, pack_manager, ctx)
+          unless pack_manager.installed?(name)
+            ctx.renderer.warning("Pack '#{name}' is not installed.")
+            return
+          end
+
+          pack_manager.remove(name)
+          ctx.renderer.info("Removed skill pack '#{name}'.")
+        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,54 @@ 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
+
+        # -- readable sequential display logic
+        def search_skills(term, ctx)
+          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
+
+        # -- readable sequential display logic
+        def list_by_category(category, ctx)
+          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/commands/skills.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class Skills < Base
+        def self.command_name = '/skills'
+        def self.description = 'List installed skill packs or browse the registry'
+
+        def execute(args, ctx)
+          case args.first
+          when 'search' then search_registry(args[1..].join(' '), ctx)
+          when 'available' then list_available(ctx)
+          when nil, 'list' then list_installed(ctx)
+          else
+            ctx.renderer.warning(
+              "Unknown subcommand '#{args.first}'. Try: /skills, /skills available, /skills search <term>"
+            )
+          end
+        rescue RubynCode::Skills::RegistryError => e
+          ctx.renderer.error(e.message)
+        end
+
+        private
+
+        def list_installed(ctx)
+          packs = RubynCode::Skills::PackManager.new.installed
+
+          if packs.empty?
+            ctx.renderer.info(
+              'No skill packs installed. Use /skills available to browse or /install-skills <name> to install.'
+            )
+            return
+          end
+
+          ctx.renderer.info("Installed skill packs (#{packs.size}):")
+          packs.each { |pack| puts "  #{format_installed_pack(pack)}" }
+        end
+
+        def list_available(ctx)
+          ctx.renderer.info('Fetching available packs from registry...')
+          result = RubynCode::Skills::RegistryClient.new.fetch_catalog
+          packs = result[:data]
+          return ctx.renderer.info('No packs found in the registry.') unless valid_results?(packs)
+
+          pack_manager = RubynCode::Skills::PackManager.new
+          ctx.renderer.info("Available skill packs (#{packs.size}):")
+          packs.each { |pack| puts "  #{format_available_pack(pack, pack_manager)}" }
+        end
+
+        def search_registry(term, ctx)
+          if term.nil? || term.strip.empty?
+            ctx.renderer.warning('Usage: /skills search <term>')
+            return
+          end
+
+          query = term.strip
+          ctx.renderer.info("Searching registry for '#{query}'...")
+          result = RubynCode::Skills::RegistryClient.new.search_packs(query)
+          packs = result[:data]
+
+          unless valid_results?(packs)
+            ctx.renderer.info("No packs found matching '#{query}'.")
+            return
+          end
+
+          ctx.renderer.info("Packs matching '#{query}' (#{packs.size}):")
+          packs.each { |pack| puts "  #{format_pack_line(pack)}" }
+        end
+
+        def valid_results?(results)
+          results.is_a?(Array) && !results.empty?
+        end
+
+        def format_installed_pack(pack)
+          version = pack[:version] ? " v#{pack[:version]}" : ''
+          desc = pack[:description].to_s.empty? ? '' : " — #{pack[:description]}"
+          "#{pack[:name]}#{version}#{desc}"
+        end
+
+        def format_available_pack(pack, pack_manager)
+          name = pack_name(pack)
+          installed = pack_manager.installed?(name) ? ' [installed]' : ''
+          "#{format_pack_line(pack)}#{installed}"
+        end
+
+        def format_pack_line(pack)
+          name = pack_name(pack)
+          desc = pack_description(pack)
+          label = desc.empty? ? '' : " — #{desc}"
+          "#{name}#{label}"
+        end
+
+        def pack_name(pack)
+          pack[:name] || pack['name']
+        end
+
+        def pack_description(pack)
+          (pack[:description] || pack['description']).to_s
+        end
+      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

@@ -34,6 +34,7 @@ module RubynCode
 
         @renderer.welcome
         @version_check.notify
+        check_skill_suggestions!
 
         at_exit { shutdown! }
 
@@ -44,6 +45,14 @@ module RubynCode
 
       private
 
+      def check_skill_suggestions!
+        suggest = Skills::AutoSuggest.new(project_root: @project_root)
+        message = suggest.check
+        @renderer.info(message) if message
+      rescue StandardError
+        # Never block session start on suggestion failure
+      end
+
       def run_input_loop
         while @running
           begin
@@ -98,6 +107,7 @@ module RubynCode
         @stream_formatter&.feed(text)
       end
 
+      # -- sequential steps with interrupt rescue
       def handle_message(input)
         @spinner.start
         @streaming_first_chunk = true
@@ -113,6 +123,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,9 @@ 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, Commands::InstallSkills,
+          Commands::RemoveSkills, Commands::Skills
         ].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")