rubyn-code 0.2.2 → 0.4.0

data/lib/rubyn_code/permissions/policy.rb

@@ -15,10 +15,10 @@ module RubynCode
       ALWAYS_ALLOW = %w[
         read_file glob grep git_status git_diff git_log
         memory_search memory_write load_skill compact
-        task web_search web_fetch
+        task web_search web_fetch ask_user
       ].to_set.freeze
 
-      def self.check(tool_name:, tool_input:, tier:, deny_list:)
+      def self.check(tool_name:, tier:, deny_list:, tool_input: nil) # rubocop:disable Lint/UnusedMethodArgument
         return :deny if deny_list.blocks?(tool_name)
         return :allow if ALWAYS_ALLOW.include?(tool_name)
 
@@ -26,17 +26,15 @@ module RubynCode
 
         return :ask if risk == :destructive
 
+        resolve_by_tier(tier, risk)
+      end
+
+      def self.resolve_by_tier(tier, risk)
         case tier
-        when Tier::ASK_ALWAYS
-          :ask
-        when Tier::ALLOW_READ
-          risk == :read ? :allow : :ask
-        when Tier::AUTONOMOUS
-          risk == :external ? :ask : :allow
-        when Tier::UNRESTRICTED
-          :allow
-        else
-          :ask
+        when Tier::ASK_ALWAYS, nil then :ask
+        when Tier::ALLOW_READ      then risk == :read ? :allow : :ask
+        when Tier::AUTONOMOUS      then risk == :external ? :ask : :allow
+        when Tier::UNRESTRICTED    then :allow
         end
       end
 
@@ -53,7 +51,7 @@ module RubynCode
         :unknown
       end
 
-      private_class_method :resolve_risk
+      private_class_method :resolve_risk, :resolve_by_tier
     end
   end
 end

data/lib/rubyn_code/permissions/prompter.rb

@@ -33,21 +33,20 @@ module RubynCode
       # @param tool_input [Hash]
       # @return [Boolean] true if the user approved
       def self.confirm_destructive(tool_name, tool_input)
-        prompt = build_prompt
         pastel = Pastel.new
+        display_destructive_warning(pastel, tool_name, tool_input)
+
+        answer = build_prompt.ask(pastel.red.bold('Type "yes" to confirm this destructive action:'))
+        answer&.strip&.downcase == 'yes'
+      rescue TTY::Prompt::Reader::InputInterrupt
+        false
+      end
 
+      def self.display_destructive_warning(pastel, tool_name, tool_input)
         $stdout.puts pastel.red.bold('WARNING: Destructive operation requested')
         $stdout.puts pastel.red('=' * 50)
         display_tool_summary(pastel, tool_name, tool_input)
         $stdout.puts pastel.red('=' * 50)
-
-        answer = prompt.ask(
-          pastel.red.bold('Type "yes" to confirm this destructive action:')
-        )
-
-        answer&.strip&.downcase == 'yes'
-      rescue TTY::Prompt::Reader::InputInterrupt
-        false
       end
 
       # @api private

data/lib/rubyn_code/protocols/plan_approval.rb

@@ -22,39 +22,44 @@ module RubynCode
         # @return [Symbol] :approved or :rejected
         def request(plan_text, prompt: nil)
           pastel = Pastel.new
-          tty = build_prompt
+          display_plan(pastel, plan_text, prompt)
 
+          approved = build_prompt.yes?(
+            pastel.yellow.bold('Do you approve this plan?'),
+            default: false
+          )
+
+          approved ? approve(pastel) : reject(pastel)
+        rescue TTY::Reader::InputInterrupt
+          $stdout.puts pastel.red("\nPlan rejected (interrupted).")
+          REJECTED
+        end
+
+        private
+
+        def display_plan(pastel, plan_text, prompt)
           $stdout.puts
           $stdout.puts pastel.cyan.bold('Proposed Plan')
           $stdout.puts pastel.cyan('=' * 60)
           $stdout.puts plan_text
           $stdout.puts pastel.cyan('=' * 60)
           $stdout.puts
+          return unless prompt
 
-          if prompt
-            $stdout.puts pastel.yellow(prompt)
-            $stdout.puts
-          end
+          $stdout.puts pastel.yellow(prompt)
+          $stdout.puts
+        end
 
-          approved = tty.yes?(
-            pastel.yellow.bold('Do you approve this plan?'),
-            default: false
-          )
+        def approve(pastel)
+          $stdout.puts pastel.green('Plan approved.')
+          APPROVED
+        end
 
-          if approved
-            $stdout.puts pastel.green('Plan approved.')
-            APPROVED
-          else
-            $stdout.puts pastel.red('Plan rejected.')
-            REJECTED
-          end
-        rescue TTY::Reader::InputInterrupt
-          $stdout.puts pastel.red("\nPlan rejected (interrupted).")
+        def reject(pastel)
+          $stdout.puts pastel.red('Plan rejected.')
           REJECTED
         end
 
-        private
-
         # Builds a TTY::Prompt instance configured for non-destructive interrupt handling.
         #
         # @return [TTY::Prompt]

data/lib/rubyn_code/self_test.rb

@@ -0,0 +1,315 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module RubynCode
+  # Programmatic smoke test that exercises every major subsystem.
+  # Mirrors the checks in skills/rubyn_self_test.md but runs without
+  # the REPL or an LLM — suitable for CI and rake tasks.
+  #
+  # rubocop:disable Metrics/ClassLength -- intentionally comprehensive
+  class SelfTest
+    Result = Data.define(:name, :passed, :detail)
+
+    attr_reader :results, :project_root
+
+    def initialize(project_root: Dir.pwd)
+      @project_root = project_root
+      @results = []
+    end
+
+    def run! # rubocop:disable Naming/PredicateMethod -- returns bool but primary purpose is side effects
+      @results = []
+
+      check_file_operations
+      check_search
+      check_bash
+      check_git
+      check_specs
+      check_compressor_strategies
+      check_skills
+      check_config
+      check_codebase_index
+      check_slash_commands
+      check_architecture
+
+      print_scorecard
+      results.all?(&:passed)
+    end
+
+    private
+
+    # ── 1. File Operations ──────────────────────────────────────────
+
+    def check_file_operations
+      check_file_read
+      check_file_write_edit_cleanup
+    rescue StandardError => e
+      record('File operations', false, e.message)
+    end
+
+    def check_file_read
+      content = File.read(File.join(project_root, 'lib/rubyn_code/version.rb'))
+      record('File read (version.rb)', content.include?('VERSION ='))
+    end
+
+    def check_file_write_edit_cleanup # rubocop:disable Metrics/AbcSize -- sequential file ops
+      tmp = File.join(project_root, '.rubyn-code/self_test_tmp.rb')
+      FileUtils.mkdir_p(File.dirname(tmp))
+
+      File.write(tmp, '# self-test')
+      record('File write (tmp)', File.exist?(tmp))
+
+      File.write(tmp, File.read(tmp).sub('# self-test', '# self-test passed'))
+      record('File edit (tmp)', File.read(tmp).include?('# self-test passed'))
+
+      File.delete(tmp)
+      record('File cleanup (tmp)', !File.exist?(tmp))
+    end
+
+    # ── 2. Search ───────────────────────────────────────────────────
+
+    def check_search
+      rb_files = Dir.glob(File.join(project_root, 'lib/**/*.rb'))
+      record('Glob lib/**/*.rb', rb_files.size >= 50, "#{rb_files.size} files")
+
+      base_classes = rb_files.count { |f| File.read(f).match?(/class.*Base/) }
+      record('Grep class.*Base', base_classes >= 3, "#{base_classes} matches")
+    rescue StandardError => e
+      record('Search', false, e.message)
+    end
+
+    # ── 3. Bash ─────────────────────────────────────────────────────
+
+    def check_bash
+      ruby_v = `ruby --version 2>&1`.strip
+      record('Bash: ruby --version', ruby_v.include?('ruby'), ruby_v)
+
+      rubocop_v = `bundle exec rubocop --version 2>&1`.strip
+      record('Bash: rubocop --version', rubocop_v.match?(/\d+\.\d+/), rubocop_v)
+    rescue StandardError => e
+      record('Bash', false, e.message)
+    end
+
+    # ── 4. Git ──────────────────────────────────────────────────────
+
+    def check_git
+      run_cmd('git status --short')
+      record('Git status', true)
+
+      log = run_cmd('git log --oneline -3')
+      record('Git log', log.match?(/^[0-9a-f]+/), log.lines.first&.strip)
+
+      run_cmd('git diff --stat')
+      record('Git diff', true)
+    rescue StandardError => e
+      record('Git', false, e.message)
+    end
+
+    # ── 5. Specs ────────────────────────────────────────────────────
+
+    def check_specs
+      %w[
+        spec/rubyn_code/tools/output_compressor_spec.rb
+        spec/rubyn_code/llm/model_router_spec.rb
+      ].each { |spec| run_single_spec(spec) }
+    rescue StandardError => e
+      record('Specs', false, e.message)
+    end
+
+    def run_single_spec(spec)
+      path = File.join(project_root, spec)
+      unless File.exist?(path)
+        record("RSpec: #{File.basename(spec)}", false, 'file not found')
+        return
+      end
+      output = run_cmd("bundle exec rspec #{path} --format progress 2>&1")
+      record("RSpec: #{File.basename(spec)}", output.include?('0 failures'))
+    end
+
+    # ── 6. Output Compressor ────────────────────────────────────────
+
+    def check_compressor_strategies
+      compressor = Tools::OutputCompressor.new
+      verified = 0
+
+      verified += verify_head_tail(compressor)
+      verified += verify_spec_summary(compressor)
+      verified += verify_top_matches(compressor)
+      verified += verify_tree_collapse(compressor)
+      verified += verify_diff_hunks(compressor)
+
+      record('Compression strategies verified', verified >= 3, "#{verified}/5 active")
+    rescue StandardError => e
+      record('Output compressor', false, e.message)
+    end
+
+    def verify_head_tail(compressor)
+      big = (1..5000).to_a.join("\n")
+      compressed = compressor.compress('bash', big)
+      pass = compressed.length < big.length
+      record('Compressor: head_tail', pass)
+      pass ? 1 : 0
+    end
+
+    def verify_spec_summary(compressor)
+      spec_out = run_cmd(
+        'bundle exec rspec spec/rubyn_code/tools/base_spec.rb --format documentation 2>&1'
+      )
+      compressed = compressor.compress('run_specs', spec_out)
+      pass = compressed.length < spec_out.length || compressed.include?('0 failures')
+      record('Compressor: spec_summary', pass)
+      pass ? 1 : 0
+    end
+
+    def verify_top_matches(compressor)
+      grep_out = rb_files_with_def.join("\n")
+      compressed = compressor.compress('grep', grep_out)
+      pass = compressed.length <= grep_out.length
+      record('Compressor: top_matches', pass)
+      pass ? 1 : 0
+    end
+
+    def verify_tree_collapse(compressor)
+      all_rb = Dir.glob(File.join(project_root, '**/*.rb')).join("\n")
+      compressed = compressor.compress('glob', all_rb)
+      pass = compressed.length <= all_rb.length
+      record('Compressor: tree_collapse', pass)
+      pass ? 1 : 0
+    end
+
+    def verify_diff_hunks(compressor)
+      diff = run_cmd('git log --oneline -1 --format=%H | xargs -I{} git diff {}~5..{} 2>/dev/null')
+      if diff.strip.empty?
+        record('Compressor: diff_hunks', true, 'SKIP — diff too small')
+        return 0
+      end
+      pass = compressor.compress('git_diff', diff).length <= diff.length
+      record('Compressor: diff_hunks', pass)
+      pass ? 1 : 0
+    end
+
+    # ── 7. Skills ───────────────────────────────────────────────────
+
+    def check_skills
+      catalog = Skills::Catalog.new(project_root)
+      skills = catalog.available
+      record('Skills catalog', skills.size >= 10, "#{skills.size} skills")
+    rescue StandardError => e
+      record('Skills', false, e.message)
+    end
+
+    # ── 8. Config ───────────────────────────────────────────────────
+
+    def check_config
+      config_path = File.expand_path('~/.rubyn-code/config.yml')
+      if File.exist?(config_path)
+        record('Config (config.yml)', File.read(config_path).include?('provider'))
+      else
+        record('Config (config.yml)', false, 'not found')
+      end
+
+      profile = File.join(project_root, '.rubyn-code/project_profile.yml')
+      record('Config (project_profile)', File.exist?(profile),
+             File.exist?(profile) ? 'exists' : 'SKIP — first session')
+    rescue StandardError => e
+      record('Config', false, e.message)
+    end
+
+    # ── 9. Codebase Index ───────────────────────────────────────────
+
+    def check_codebase_index
+      path = File.join(project_root, '.rubyn-code/codebase_index.json')
+      record('Codebase index', File.exist?(path),
+             File.exist?(path) ? 'exists' : 'SKIP — first session')
+    rescue StandardError => e
+      record('Codebase index', false, e.message)
+    end
+
+    # ── 10. Slash Commands ──────────────────────────────────────────
+
+    def check_slash_commands
+      cmd_dir = File.join(project_root, 'lib/rubyn_code/cli/commands')
+      infra = %w[base.rb context.rb registry.rb]
+      cmds = Dir.glob(File.join(cmd_dir, '*.rb')).reject { |f| infra.include?(File.basename(f)) }
+      record('Slash commands', cmds.size >= 15, "#{cmds.size} commands")
+    rescue StandardError => e
+      record('Slash commands', false, e.message)
+    end
+
+    # ── 11. Architecture ────────────────────────────────────────────
+
+    def check_architecture
+      check_autoloads
+      check_layer_dirs
+      check_core_modules
+    rescue StandardError => e
+      record('Architecture', false, e.message)
+    end
+
+    def check_autoloads
+      content = File.read(File.join(project_root, 'lib/rubyn_code.rb'))
+      autoloads = content.scan('autoload').size
+      record('Autoload entries', autoloads >= 40, "#{autoloads} entries")
+    end
+
+    def check_layer_dirs
+      dirs = Dir.glob(File.join(project_root, 'lib/rubyn_code/*/'))
+      record('Layer directories', dirs.size >= 14, "#{dirs.size} dirs")
+    end
+
+    def check_core_modules
+      content = File.read(File.join(project_root, 'lib/rubyn_code.rb'))
+      core = %w[Agent Tools Context Skills Memory Observability Learning]
+      found = core.select { |m| content.include?("module #{m}") }
+      record('Core modules', found.size == core.size, "#{found.size}/#{core.size}")
+    end
+
+    # ── Helpers ─────────────────────────────────────────────────────
+
+    def record(name, passed, detail = nil)
+      @results << Result.new(name: name, passed: passed, detail: detail)
+    end
+
+    def run_cmd(cmd)
+      `cd #{project_root} && #{cmd} 2>&1`.strip
+    end
+
+    def rb_files_with_def
+      Dir.glob(File.join(project_root, 'lib/**/*.rb')).flat_map do |f|
+        File.readlines(f).select { |l| l.include?('def ') }.map { |l| "#{f}:#{l.strip}" }
+      end
+    end
+
+    def print_scorecard
+      puts
+      puts 'Rubyn Self-Test Results'
+      puts '=' * 50
+      results.each_with_index { |r, i| print_result(r, i + 1) }
+      print_summary
+    end
+
+    def print_result(result, num)
+      icon = result.passed ? "\e[32m✅\e[0m" : "\e[31m❌\e[0m"
+      suffix = result.detail ? " — #{result.detail}" : ''
+      puts format(' %2<num>d. %<icon>s %<name>s%<suffix>s',
+                  num: num, icon: icon, name: result.name, suffix: suffix)
+    end
+
+    def print_summary
+      passed = results.count(&:passed)
+      total = results.size
+      pct = total.positive? ? (passed * 100.0 / total).round : 0
+      failed = total - passed
+
+      puts '=' * 50
+      if failed.zero?
+        puts "\e[32mScore: #{passed}/#{total} (#{pct}%) — All systems go!\e[0m"
+      else
+        puts "\e[33mScore: #{passed}/#{total} (#{pct}%) — #{failed} failures\e[0m"
+      end
+      puts
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end

data/lib/rubyn_code/skills/catalog.rb

@@ -24,11 +24,53 @@ module RubynCode
         @index
       end
 
+      def list
+        available.map { |e| e[:name] }
+      end
+
       def find(name)
         entry = available.find { |e| e[:name] == name.to_s }
         entry&.fetch(:path)
       end
 
+      # Search skill content — matches against names, descriptions, and tags.
+      # Returns matching entries sorted by relevance (number of field matches).
+      #
+      # @param term [String] search term (case-insensitive)
+      # @return [Array<Hash>] matching entries with :name, :description, :path, :relevance
+      def search(term)
+        pattern = /#{Regexp.escape(term)}/i
+        matches = available.filter_map do |entry|
+          relevance = compute_relevance(entry, pattern)
+          next if relevance.zero?
+
+          entry.merge(relevance: relevance)
+        end
+        matches.sort_by { |e| -e[:relevance] }
+      end
+
+      # Filter skills by category (subdirectory name).
+      # Skills are organized in subdirectories under each skills_dir.
+      #
+      # @param category [String] category/directory name (e.g. "rails", "testing")
+      # @return [Array<Hash>] matching entries
+      def by_category(category)
+        normalized = category.to_s.downcase
+        available.select do |entry|
+          path_category(entry[:path]).downcase == normalized
+        end
+      end
+
+      # Return the list of unique categories derived from skill file paths.
+      #
+      # @return [Array<String>] sorted category names
+      def categories
+        available.map { |e| path_category(e[:path]) }
+                 .reject(&:empty?)
+                 .uniq
+                 .sort
+      end
+
       private
 
       def build_index
@@ -60,11 +102,35 @@ module RubynCode
         {
           name: name,
           description: doc.description,
+          tags: doc.tags,
           path: File.expand_path(path)
         }
       rescue StandardError
         nil
       end
+
+      def compute_relevance(entry, pattern)
+        score = 0
+        score += 3 if entry[:name].to_s.match?(pattern)
+        score += 2 if entry[:description].to_s.match?(pattern)
+        Array(entry[:tags]).each { |tag| score += 1 if tag.to_s.match?(pattern) }
+        score
+      end
+
+      # Derive a category from the skill file path.
+      # The category is the immediate parent directory name relative to one of
+      # the skills_dirs. Skills at the top level of a skills_dir have no category.
+      def path_category(path)
+        skills_dirs.each do |dir|
+          expanded = File.expand_path(dir)
+          next unless path.start_with?(expanded)
+
+          relative = path.delete_prefix("#{expanded}/")
+          parts = relative.split('/')
+          return parts.size > 1 ? parts.first : ''
+        end
+        ''
+      end
     end
   end
 end

data/lib/rubyn_code/skills/document.rb

@@ -19,30 +19,30 @@ module RubynCode
       class << self
         def parse(content, filename: nil)
           match = FRONTMATTER_PATTERN.match(content)
+          match ? parse_with_frontmatter(match) : parse_without_frontmatter(content, filename)
+        end
 
-          if match
-            frontmatter = YAML.safe_load(match[1], permitted_classes: [Symbol]) || {}
-            body = match[2].to_s.strip
+        def parse_with_frontmatter(match)
+          frontmatter = YAML.safe_load(match[1], permitted_classes: [Symbol]) || {}
+          new(
+            name: frontmatter['name'].to_s,
+            description: frontmatter['description'].to_s,
+            tags: Array(frontmatter['tags']),
+            body: match[2].to_s.strip
+          )
+        end
 
-            new(
-              name: frontmatter['name'].to_s,
-              description: frontmatter['description'].to_s,
-              tags: Array(frontmatter['tags']),
-              body: body
-            )
-          else
-            body = content.to_s.strip
-            title = extract_title(body)
-            derived_name = filename ? File.basename(filename, '.*').tr('_', '-') : title_to_name(title)
-            tags = derive_tags(derived_name, body)
+        def parse_without_frontmatter(content, filename)
+          body = content.to_s.strip
+          title = extract_title(body)
+          derived_name = filename ? File.basename(filename, '.*').tr('_', '-') : title_to_name(title)
 
-            new(
-              name: derived_name,
-              description: title,
-              tags: tags,
-              body: body
-            )
-          end
+          new(
+            name: derived_name,
+            description: title,
+            tags: derive_tags(derived_name, body),
+            body: body
+          )
         end
 
         def parse_file(path)
@@ -53,6 +53,15 @@ module RubynCode
           parse(content, filename: path)
         end
 
+        TAG_RULES = [
+          ['ruby',        /\bruby\b/i],
+          ['rails',       /\brails\b/i],
+          ['rspec',       /\brspec\b/i],
+          ['testing',     /\b(?:test|spec|minitest)\b/i],
+          ['patterns',    /\b(?:pattern|design|solid)\b/i],
+          ['refactoring', /\brefactor/i]
+        ].freeze
+
         private
 
         def extract_title(body)
@@ -65,14 +74,9 @@ module RubynCode
         end
 
         def derive_tags(name, body)
-          tags = []
-          tags << 'ruby' if body.match?(/\bruby\b/i) || name.include?('ruby')
-          tags << 'rails' if body.match?(/\brails\b/i) || name.include?('rails')
-          tags << 'rspec' if body.match?(/\brspec\b/i) || name.include?('rspec')
-          tags << 'testing' if body.match?(/\b(test|spec|minitest)\b/i)
-          tags << 'patterns' if body.match?(/\b(pattern|design|solid)\b/i)
-          tags << 'refactoring' if body.match?(/\brefactor/i)
-          tags.uniq
+          TAG_RULES.each_with_object([]) do |(tag, pattern), tags|
+            tags << tag if body.match?(pattern) || name.include?(tag)
+          end.uniq
         end
       end
     end

data/lib/rubyn_code/skills/loader.rb

@@ -33,6 +33,31 @@ module RubynCode
         catalog.descriptions
       end
 
+      # Suggest skills based on what the codebase index reveals about the project.
+      #
+      # Inspects class names, parent classes, and file paths in the index to
+      # detect common Rails patterns (Devise, ActionMailer, ActiveJob, etc.)
+      # and returns matching skill names.
+      #
+      # @param codebase_index [RubynCode::Index::CodebaseIndex, nil]
+      # @param project_profile [Object, nil] reserved for future profile-based hints
+      # @return [Array<String>] suggested skill names (not loaded automatically)
+      def suggest_skills(codebase_index: nil, project_profile: nil) # rubocop:disable Lint/UnusedMethodArgument, Metrics/CyclomaticComplexity -- project_profile reserved for future use
+        return [] unless codebase_index
+
+        suggestions = []
+        node_names = codebase_index.nodes.map { |n| n['name'].to_s }
+        node_files = codebase_index.nodes.map { |n| n['file'].to_s }
+
+        suggestions << 'authentication' if detect_devise?(node_names, node_files)
+        suggestions << 'mailer'         if detect_action_mailer?(node_names, node_files)
+        suggestions << 'background-job' if detect_active_job?(node_names, node_files)
+
+        suggestions
+      rescue StandardError
+        []
+      end
+
       private
 
       def format_skill(doc)
@@ -50,6 +75,24 @@ module RubynCode
             .gsub('>', '&gt;')
             .gsub('"', '&quot;')
       end
+
+      # Devise detection: look for Devise-related class names or config files.
+      def detect_devise?(node_names, node_files)
+        node_names.any? { |n| n.match?(/\bDevise\b/i) } ||
+          node_files.any? { |f| f.include?('devise') }
+      end
+
+      # ActionMailer detection: look for mailer classes or mailer directory.
+      def detect_action_mailer?(node_names, node_files)
+        node_names.any? { |n| n.match?(/Mailer\b/) } ||
+          node_files.any? { |f| f.include?('app/mailers/') }
+      end
+
+      # ActiveJob detection: look for job classes or jobs directory.
+      def detect_active_job?(node_names, node_files)
+        node_names.any? { |n| n.match?(/Job\b/) } ||
+          node_files.any? { |f| f.include?('app/jobs/') }
+      end
     end
   end
 end