rubyn-code 0.4.0 → 0.5.1

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,7 @@ 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
@@ -47,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
@@ -60,23 +64,25 @@ module RubynCode
         '--auth' => :auth, '--setup' => :setup
       }.freeze
       BOOLEAN_FLAGS = { '--yolo' => :yolo, '--debug' => :debug, '--skip-setup' => :skip_setup, '--ide' => :ide }.freeze
-      VALUE_FLAGS = { '--permission-mode' => :permission_mode }.freeze
+      VALUE_FLAGS = { '--permission-mode' => :permission_mode, '--dir' => :workspace_dir }.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 :ide     then run_ide
-        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
 
@@ -116,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)
@@ -155,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)
@@ -198,13 +209,76 @@ module RubynCode
 
       def run_ide
         mode = resolve_permission_mode
-        IDE::Server.new(permission_mode: mode).run
+        IDE::Server.new(permission_mode: mode, workspace_path: @options[:workspace_dir]).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(

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/megaplan.rb

@@ -0,0 +1,50 @@
+  # frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      # `/megaplan` REPL command — mirrors the VS Code chat's chat-resident
+      # megaplan entry. Loads the megaplan skill (from the shared
+      # skills catalog) into the conversation, flips plan mode ON so the
+      # agent is restricted to read-only tools, and kicks off a
+      # conversational interview.
+      #
+      # The interview itself is chat-style here (multi-turn natural-
+      # language Q&A), not the structured question-card UI the VS Code
+      # extension uses. Same skill content driving both surfaces.
+      class Megaplan < Base
+        def self.command_name = '/megaplan'
+        def self.description  = 'Plan a feature in phases (interview, then numbered phase docs)'
+        def self.aliases      = ['/mega-plan'].freeze
+
+        def execute(args, ctx)
+          content = ctx.skill_loader.load('megaplan')
+          ctx.conversation.add_user_message("<skill>#{content}</skill>")
+          ctx.renderer.info('Megaplan mode — interviewer with read-only tools 🧠')
+
+          ctx.send_message(build_prompt(args.join(' ').strip))
+
+          { action: :set_plan_mode, enabled: true }
+        rescue StandardError => e
+          ctx.renderer.error("Megaplan error: #{e.message}")
+          nil
+        end
+
+        private
+
+        def build_prompt(feature)
+          base = <<~PROMPT.strip
+            Conduct a megaplan interview, following the megaplan skill loaded above.
+            Stay strictly read-only: you may inspect files, search code, and check
+            git state, but do NOT edit, write, run shell mutations, or call any
+            destructive tool. Ask ONE question at a time. When you have enough,
+            output the final phase breakdown as a numbered outline.
+          PROMPT
+          return base if feature.empty?
+
+          "#{base}\n\nThe feature to plan: #{feature}"
+        end
+      end
+    end
+  end
+end

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

@@ -55,7 +55,8 @@ module RubynCode
           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
+        # -- 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]

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

@@ -33,7 +33,8 @@ module RubynCode
           skills.each { |skill| puts "  /#{skill[:name]}: #{skill[:description]}" }
         end
 
-        def search_skills(term, ctx) # rubocop:disable Metrics/AbcSize -- readable sequential display logic
+        # -- readable sequential display logic
+        def search_skills(term, ctx)
           if term.nil? || term.strip.empty?
             ctx.renderer.warning('Usage: /skill search <term>')
             return
@@ -49,7 +50,8 @@ module RubynCode
           display_entries(results)
         end
 
-        def list_by_category(category, ctx) # rubocop:disable Metrics/AbcSize -- readable sequential display logic
+        # -- 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?
 

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/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,7 +107,8 @@ module RubynCode
         @stream_formatter&.feed(text)
       end
 
-      def handle_message(input) # rubocop:disable Metrics/AbcSize -- sequential steps with interrupt rescue
+      # -- sequential steps with interrupt rescue
+      def handle_message(input)
         @spinner.start
         @streaming_first_chunk = true
 

data/lib/rubyn_code/cli/repl_commands.rb

@@ -22,7 +22,9 @@ module RubynCode
           Commands::Spawn, Commands::Doctor, Commands::Tokens,
           Commands::Plan, Commands::ContextInfo, Commands::Diff,
           Commands::Model, Commands::NewSession, Commands::Mcp,
-          Commands::Provider
+          Commands::Provider, Commands::InstallSkills,
+          Commands::RemoveSkills, Commands::Skills,
+          Commands::Megaplan
         ].each { |cmd| @command_registry.register(cmd) }
       end
 

data/lib/rubyn_code/cli/repl_setup.rb

@@ -42,9 +42,41 @@ module RubynCode
         @budget_enforcer = Observability::BudgetEnforcer.new(@db, session_id: current_session_id)
         @background_worker = Background::Worker.new(project_root: @project_root)
         @skill_loader = Skills::Loader.new(Skills::Catalog.new(skill_dirs))
+        @skill_matcher = build_skill_matcher
+        @web_skill_autoload = build_web_skill_autoload
         @session_persistence = Memory::SessionPersistence.new(@db)
       end
 
+      def build_skill_matcher
+        return nil unless skills_autoload_enabled?
+
+        Skills::Matcher.new(catalog: @skill_loader.catalog, project_root: @project_root)
+      end
+
+      def build_web_skill_autoload
+        return nil unless @skill_matcher && skills_autoload_enabled?
+
+        Skills::RegistryAutoload.new(
+          loader: @skill_loader,
+          matcher: @skill_matcher,
+          on_fetching: on_pack_fetching_callback
+        )
+      end
+
+      def skills_autoload_enabled?
+        Config::Settings.new.skills_autoload
+      rescue Config::Settings::LoadError
+        true
+      end
+
+      def on_skills_autoloaded_callback
+        ->(names) { @renderer.system_message("📚 Loaded: #{names.join(' · ')}") }
+      end
+
+      def on_pack_fetching_callback
+        ->(name) { @renderer.system_message("📥 Fetching skill pack '#{name}' from registry…") }
+      end
+
       def setup_executor_callbacks!
         @tool_executor.llm_client = @llm_client
         @tool_executor.background_worker = @background_worker
@@ -107,7 +139,10 @@ module RubynCode
           on_tool_call: ->(name, params) { handle_on_tool_call(name, params) },
           on_tool_result: ->(name, result, _is_error = false) { handle_on_tool_result(name, result) },
           on_text: ->(text) { handle_on_text(text) },
-          skill_loader: @skill_loader, project_root: @project_root
+          on_skills_autoloaded: on_skills_autoloaded_callback,
+          skill_loader: @skill_loader, skill_matcher: @skill_matcher,
+          web_skill_autoload: @web_skill_autoload,
+          project_root: @project_root
         )
       end
 
@@ -139,6 +174,8 @@ module RubynCode
         dirs << project_skills if Dir.exist?(project_skills)
         user_skills = File.join(Config::Defaults::HOME_DIR, 'skills')
         dirs << user_skills if Dir.exist?(user_skills)
+        skill_packs = File.join(Config::Defaults::HOME_DIR, 'skill-packs')
+        dirs << skill_packs if Dir.exist?(skill_packs)
         dirs
       end