rubyn-code 0.3.0 → 0.5.0

data/lib/rubyn_code/cli/app.rb

@@ -2,7 +2,7 @@
 
 module RubynCode
   module CLI
-    class App
+    class App # rubocop:disable Metrics/ClassLength -- CLI dispatch requires many small methods
       def self.start(argv)
         new(argv).run
       end
@@ -26,6 +26,9 @@ module RubynCode
           rubyn-code --resume [ID]      Resume a previous session
           rubyn-code --setup            Pin rubyn-code to bypass rbenv/rvm
           rubyn-code --auth             Authenticate with Claude
+          rubyn-code --install-skills NAME  Install a skill pack from the registry
+          rubyn-code --ide              Start IDE server (VS Code extension)
+          rubyn-code --permission-mode MODE  Set permission mode (default, accept_edits, plan_only, auto, dont_ask, bypass)
           rubyn-code --version          Show version
           rubyn-code --help             Show this help
 
@@ -45,6 +48,9 @@ module RubynCode
           /cost          Show usage costs
           /tasks         List tasks
           /skill [name]  Load or list skills
+          /skills        List installed and community skill packs
+          /install-skills Install skill packs from rubyn.ai
+          /remove-skills  Remove an installed skill pack
 
         Environment:
           Config:  ~/.rubyn-code/config.yml
@@ -57,22 +63,26 @@ module RubynCode
         '--help' => :help, '-h' => :help,
         '--auth' => :auth, '--setup' => :setup
       }.freeze
-      BOOLEAN_FLAGS = { '--yolo' => :yolo, '--debug' => :debug }.freeze
+      BOOLEAN_FLAGS = { '--yolo' => :yolo, '--debug' => :debug, '--skip-setup' => :skip_setup, '--ide' => :ide }.freeze
+      VALUE_FLAGS = { '--permission-mode' => :permission_mode }.freeze
       DAEMON_INT_FLAGS = { '--max-runs' => :max_runs, '--idle-timeout' => :idle_timeout,
                            '--poll-interval' => :poll_interval }.freeze
       DAEMON_STR_FLAGS = { '--name' => :agent_name, '--role' => :role }.freeze
 
       private
 
-      def dispatch_command(command) # rubocop:disable Metrics/CyclomaticComplexity -- unavoidable dispatch switch
+      # -- unavoidable dispatch switch
+      def dispatch_command(command)
         case command
-        when :version then puts "rubyn-code #{RubynCode::VERSION}"
-        when :auth    then run_auth
-        when :setup   then run_setup
-        when :help    then display_help
-        when :run     then run_single_prompt(@options[:prompt])
-        when :daemon  then run_daemon
-        when :repl    then run_repl
+        when :version        then puts "rubyn-code #{RubynCode::VERSION}"
+        when :auth           then run_auth
+        when :setup          then run_setup
+        when :help           then display_help
+        when :run            then run_single_prompt(@options[:prompt])
+        when :ide            then run_ide
+        when :daemon         then run_daemon
+        when :install_skills then run_install_skills(@options[:install_skills_names])
+        when :repl           then run_repl
         end
       end
 
@@ -83,6 +93,7 @@ module RubynCode
           idx = parse_single_option(argv, idx, options)
           idx += 1
         end
+        options[:command] = :ide if options[:ide]
         options
       end
 
@@ -93,6 +104,9 @@ module RubynCode
           options[:command] = SIMPLE_FLAGS[arg]
         elsif BOOLEAN_FLAGS.key?(arg)
           options[BOOLEAN_FLAGS[arg]] = true
+        elsif VALUE_FLAGS.key?(arg)
+          options[VALUE_FLAGS[arg]] = argv[idx + 1]
+          idx += 1
         else
           idx = parse_value_option(argv, idx, options)
         end
@@ -108,6 +122,10 @@ module RubynCode
           options[:command] = :run
           options[:prompt] = argv[idx + 1]
           idx + 1
+        when '--install-skills'
+          options[:command] = :install_skills
+          options[:install_skills_names] = collect_pack_names(argv, idx + 1)
+          argv.length - 1
         when 'daemon'
           options[:command] = :daemon
           parse_daemon_options!(argv, idx + 1, options)
@@ -147,7 +165,8 @@ module RubynCode
         idx
       end
 
-      def parse_daemon_value_option(argv, idx, options) # rubocop:disable Metrics/AbcSize -- option dispatch with hash lookup
+      # -- option dispatch with hash lookup
+      def parse_daemon_value_option(argv, idx, options)
         arg = argv[idx]
         daemon = options[:daemon]
         if DAEMON_INT_FLAGS.key?(arg)
@@ -188,11 +207,80 @@ module RubynCode
         puts response
       end
 
+      def run_ide
+        mode = resolve_permission_mode
+        IDE::Server.new(permission_mode: mode).run
+      end
+
       def run_daemon
         DaemonRunner.new(@options).run
       end
 
+      def run_install_skills(names)
+        renderer = Renderer.new
+        client = Skills::RegistryClient.new
+        installer = Skills::PackInstaller.new(
+          registry_client: client,
+          project_root: Dir.pwd,
+          global: @options[:install_skills_global]
+        )
+
+        if names.empty? || names.include?('--update')
+          renderer.info('Checking for updates on all installed packs...')
+          results = installer.update_all do |event, data|
+            report_install_progress(renderer, event, data)
+          end
+          updated = results.select { |r| r[:status] == :installed }
+          if updated.empty?
+            renderer.info('All packs are up to date.')
+          else
+            renderer.info("Updated #{updated.size} pack(s).")
+          end
+        else
+          installer.install(names) do |event, data|
+            report_install_progress(renderer, event, data)
+          end
+        end
+      rescue Skills::RegistryError => e
+        renderer.error("Registry error: #{e.message}")
+        exit(1)
+      rescue StandardError => e
+        renderer.error("Install failed: #{e.message}")
+        exit(1)
+      end
+
+      def report_install_progress(renderer, event, data)
+        case event
+        when :fetching   then renderer.info("Fetching #{data[:name]} from rubyn.ai...")
+        when :downloading then renderer.info("  Downloading #{data[:total]} skill files...")
+        when :installed
+          data[:files].each { |f| puts "  → #{data[:name]}/#{f}" }
+          renderer.info("Installed #{data[:files].size} skills to .rubyn-code/skills/#{data[:name]}/")
+        when :up_to_date then renderer.info("#{data[:name]} is already up to date (v#{data[:version]}).")
+        when :error      then renderer.error("Failed: #{data[:name]}: #{data[:message]}")
+        end
+      end
+
+      def collect_pack_names(argv, start)
+        names = []
+        idx = start
+        while idx < argv.length
+          arg = argv[idx]
+          break if arg.start_with?('-') && arg != '--update' && arg != '--global'
+
+          if arg == '--global'
+            @options ||= {}
+            @options[:install_skills_global] = true
+          else
+            names << arg
+          end
+          idx += 1
+        end
+        names
+      end
+
       def run_repl
+        maybe_first_run!
         REPL.new(
           session_id: @options[:session_id],
           project_root: Dir.pwd,
@@ -200,6 +288,23 @@ module RubynCode
         ).run
       end
 
+      def maybe_first_run!
+        return unless FirstRun.needed?
+        return if FirstRun.skipped?(skip_flag: @options[:skip_setup])
+
+        FirstRun.new.run
+      end
+
+      def resolve_permission_mode
+        if @options[:permission_mode]
+          @options[:permission_mode].to_sym
+        elsif @options[:yolo]
+          :bypass
+        else
+          :default
+        end
+      end
+
       def display_help
         puts HELP_TEXT
       end

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

@@ -14,6 +14,9 @@ module RubynCode
           check_auth
           check_skills
           check_project
+          check_mcp
+          check_codebase_index
+          check_skill_catalog
         ].freeze
 
         def execute(_args, ctx)
@@ -97,6 +100,76 @@ module RubynCode
           ['Project detected', true, "#{type} at #{ctx.project_root}"]
         end
 
+        def check_mcp(ctx)
+          config_path = File.join(ctx.project_root, MCP::Config::CONFIG_FILENAME)
+          return ['MCP connectivity', false, 'mcp.json not found'] unless File.exist?(config_path)
+
+          servers = MCP::Config.load(ctx.project_root)
+          return ['MCP connectivity', false, 'no servers configured'] if servers.empty?
+
+          reachable = servers.count { |s| mcp_server_reachable?(s) }
+          detail = "#{reachable}/#{servers.size} servers reachable"
+          ['MCP connectivity', reachable == servers.size, detail]
+        rescue StandardError => e
+          ['MCP connectivity', false, e.message]
+        end
+
+        def mcp_server_reachable?(server)
+          command = server[:command]
+          return false if command.nil? || command.empty?
+
+          # Check if the command binary exists on PATH
+          system("command -v #{command} > /dev/null 2>&1")
+        end
+
+        def check_codebase_index(ctx)
+          index_path = File.join(ctx.project_root, Index::CodebaseIndex::INDEX_DIR,
+                                 Index::CodebaseIndex::INDEX_FILE)
+          return ['Codebase index', false, 'index not found'] unless File.exist?(index_path)
+
+          mtime = File.mtime(index_path)
+          age_hours = ((Time.now - mtime) / 3600).round(1)
+          stale = age_hours > 24
+          detail = "#{age_hours}h old#{' (stale — consider reindexing)' if stale}"
+          ['Codebase index', !stale, detail]
+        rescue StandardError => e
+          ['Codebase index', false, e.message]
+        end
+
+        def check_skill_catalog(ctx)
+          catalog = ctx.skill_loader.catalog
+          entries = catalog.available
+          return ['Skill catalog', false, 'no skills found'] if entries.empty?
+
+          malformed = count_malformed_skills(catalog.skills_dirs)
+          detail = "#{entries.size} skills loaded"
+          detail += ", #{malformed} malformed" if malformed.positive?
+          ['Skill catalog', malformed.zero?, detail]
+        rescue StandardError => e
+          ['Skill catalog', false, e.message]
+        end
+
+        def count_malformed_skills(skills_dirs)
+          count = 0
+          skills_dirs.each do |dir|
+            next unless File.directory?(dir)
+
+            Dir.glob(File.join(dir, '**/*.md')).each do |path|
+              count += 1 unless valid_skill_file?(path)
+            end
+          end
+          count
+        end
+
+        def valid_skill_file?(path)
+          content = File.read(path, 1024, encoding: 'UTF-8')
+                        .encode('UTF-8', invalid: :replace, undef: :replace, replace: '')
+          doc = Skills::Document.parse(content, filename: path)
+          !doc.name.nil? && !doc.name.empty?
+        rescue StandardError
+          false
+        end
+
         def detect_project_type(root)
           return 'Rails' if File.exist?(File.join(root, 'config', 'application.rb'))
           return 'Ruby' if File.exist?(File.join(root, 'Rakefile'))

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class InstallSkills < Base
+        def self.command_name = '/install-skills'
+        def self.description = 'Install skill packs from the Rubyn registry'
+
+        def execute(args, ctx)
+          if args.empty?
+            ctx.renderer.warning('Usage: /install-skills <pack-name> [pack-name ...]')
+            return
+          end
+
+          pack_manager = RubynCode::Skills::PackManager.new
+          registry = RubynCode::Skills::RegistryClient.new
+
+          args.each { |name| install_pack(name, registry, pack_manager, ctx) }
+        rescue RubynCode::Skills::RegistryError => e
+          ctx.renderer.error(e.message)
+        end
+
+        private
+
+        def install_pack(name, registry, pack_manager, ctx)
+          if pack_manager.installed?(name)
+            ctx.renderer.warning("Pack '#{name}' is already installed. Use /remove-skills first to reinstall.")
+            return
+          end
+
+          ctx.renderer.info("Fetching pack '#{name}' from registry...")
+          result = registry.fetch_pack(name)
+          pack_manager.install(result[:data], etag: result[:etag])
+          ctx.renderer.info("Installed skill pack '#{name}' successfully.")
+        rescue RubynCode::Skills::RegistryError => e
+          ctx.renderer.error("Failed to install '#{name}': #{e.message}")
+        rescue ArgumentError => e
+          ctx.renderer.error("Invalid pack data for '#{name}': #{e.message}")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class ListSkills < Base
+        def self.command_name = '/skills'
+        def self.description = 'List installed skills or browse the registry'
+
+        def execute(args, ctx)
+          if args.include?('--available')
+            list_available(ctx)
+          else
+            list_installed(ctx)
+          end
+        rescue Skills::RegistryError => e
+          ctx.renderer.error("Registry error: #{e.message}")
+        rescue StandardError => e
+          ctx.renderer.error("Skills error: #{e.message}")
+        end
+
+        private
+
+        def list_installed(ctx)
+          catalog = ctx.skill_loader.catalog
+          all_skills = catalog.available
+          buckets = partition_skills(all_skills, ctx)
+
+          ctx.renderer.info("Loaded skills (#{all_skills.size} total)")
+          puts
+
+          render_builtin(buckets[:builtin], catalog)
+          render_packs(buckets[:packs])
+          render_community(buckets[:community], buckets[:packs].any?)
+        end
+
+        def partition_skills(all_skills, ctx)
+          community_dir = File.join(ctx.project_root, '.rubyn-code', 'skills')
+          global_dir = File.join(Config::Defaults::HOME_DIR, 'skills')
+          pack_dir = File.join(Config::Defaults::HOME_DIR, 'skill-packs')
+
+          buckets = { builtin: [], community: [], packs: [] }
+          all_skills.each do |skill|
+            buckets[bucket_for(skill[:path].to_s, pack_dir, community_dir, global_dir)] << skill
+          end
+          buckets
+        end
+
+        def bucket_for(path, pack_dir, community_dir, global_dir)
+          return :packs if path.start_with?(pack_dir)
+          return :community if path.start_with?(community_dir) || path.start_with?(global_dir)
+
+          :builtin
+        end
+
+        def render_builtin(builtin, catalog)
+          puts "  Built-in (#{builtin.size})"
+          builtin.group_by { |s| category_from_path(s[:path], catalog.skills_dirs) }
+                 .sort_by { |cat, _| cat }
+                 .each do |cat, skills|
+            label = cat.empty? ? 'general' : cat
+            puts "    #{label}: #{skills.map { |s| s[:name] }.join(', ')}"
+          end
+        end
+
+        def render_packs(packs)
+          return if packs.empty?
+
+          puts
+          summary = packs.group_by { |s| pack_from_path(s[:path]) }
+                         .sort
+                         .map { |pack, skills| "#{pack} (#{skills.size})" }
+                         .join(', ')
+          puts "  Skill packs: #{summary}"
+        end
+
+        def render_community(community, packs_present)
+          if community.any?
+            puts
+            summary = community.group_by { |s| pack_from_path(s[:path]) }
+                               .map { |pack, skills| "#{pack} (#{skills.size})" }
+                               .join(', ')
+            puts "  Community: #{summary}"
+          elsif !packs_present
+            puts
+            puts '  Skill packs: none installed'
+            puts '  Run /skills --available to browse, or /install-skills <name> to install.'
+          end
+        end
+
+        def list_available(ctx) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- readable catalog display
+          client = Skills::RegistryClient.new
+          catalog_data = client.fetch_catalog
+          packs = catalog_data['packs'] || []
+
+          if packs.empty?
+            ctx.renderer.info('No packs available in the registry.')
+            return
+          end
+
+          installer = Skills::PackInstaller.new(
+            registry_client: client,
+            project_root: ctx.project_root
+          )
+
+          ctx.renderer.info("Available skill packs (#{packs.size})")
+          puts
+
+          # Group by category
+          by_category = packs.group_by { |p| p['category'] || 'other' }
+          by_category.sort_by { |cat, _| cat }.each do |category, cat_packs|
+            puts "  #{category.capitalize}"
+            cat_packs.each do |pack|
+              installed = installer.installed?(pack['name'])
+              marker = installed ? ' ✓' : ''
+              desc = pack['description']&.slice(0, 50) || ''
+              puts "    #{pack['name'].ljust(20)} #{desc}  (#{pack['skillCount']} skills)#{marker}"
+            end
+            puts
+          end
+
+          puts '  Install with: /install-skills <name>'
+        end
+
+        def category_from_path(path, skills_dirs)
+          skills_dirs.each do |dir|
+            expanded = File.expand_path(dir)
+            next unless path.to_s.start_with?(expanded)
+
+            relative = path.delete_prefix("#{expanded}/")
+            parts = relative.split('/')
+            return parts.size > 1 ? parts.first : ''
+          end
+          ''
+        end
+
+        def pack_from_path(path)
+          # Pack-style layouts: .rubyn-code/skills/<pack>/<file>.md
+          # or .rubyn-code/skill-packs/<pack>/<file>.md
+          parts = path.to_s.split('/')
+          idx = parts.rindex('skill-packs') || parts.rindex('skills')
+          return 'unknown' unless idx
+
+          parts[idx + 1] || 'unknown'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class Mcp < Base
+        def self.command_name = '/mcp'
+        def self.description = 'MCP server status'
+
+        def execute(_args, ctx)
+          configs = load_configs(ctx.project_root)
+
+          if configs.empty?
+            ctx.renderer.info('No MCP servers configured.')
+            puts '  Add servers to .rubyn-code/mcp.json — see docs/MCP.md for details.'
+            return
+          end
+
+          ctx.renderer.info("MCP servers (#{configs.size}):")
+          puts
+
+          configs.each { |cfg| render_server(cfg) }
+        end
+
+        private
+
+        def load_configs(project_root)
+          MCP::Config.load(project_root)
+        end
+
+        def render_server(cfg)
+          client = build_client(cfg)
+          status, tool_count = probe_server(client)
+          icon = status_icon(status)
+          tools_label = tool_count ? " (#{tool_count} tools)" : ''
+
+          puts "  #{icon} #{cfg[:name]} [#{status}]#{tools_label}"
+          render_transport_info(cfg)
+        ensure
+          client&.disconnect! if client&.connected?
+        end
+
+        def build_client(cfg)
+          MCP::Client.from_config(cfg)
+        end
+
+        def probe_server(client)
+          client.connect!
+          tool_count = client.tools.size
+          [:connected, tool_count]
+        rescue StandardError
+          [:error, nil]
+        end
+
+        def render_transport_info(cfg)
+          if cfg[:url]
+            puts "    transport: SSE  url: #{cfg[:url]}"
+          else
+            puts "    transport: stdio  command: #{cfg[:command]} #{cfg[:args].join(' ')}".rstrip
+          end
+        end
+
+        def status_icon(status)
+          case status
+          when :connected then green('*')
+          when :error     then red('x')
+          else yellow('?')
+          end
+        end
+
+        def green(text)  = "\e[32m#{text}\e[0m"
+        def red(text)    = "\e[31m#{text}\e[0m"
+        def yellow(text) = "\e[33m#{text}\e[0m"
+      end
+    end
+  end
+end

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

@@ -68,7 +68,28 @@ module RubynCode
           current = client.model
           ctx.renderer.info("Provider: #{provider}")
           ctx.renderer.info("Current model: #{current}")
-          show_available(ctx)
+          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)
@@ -85,9 +106,18 @@ module RubynCode
           case provider
           when 'anthropic' then LLM::Adapters::Anthropic::AVAILABLE_MODELS
           when 'openai' then LLM::Adapters::OpenAI::AVAILABLE_MODELS
-          else []
+          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
   end