rubyn-code 0.2.2 → 0.3.0

data/lib/rubyn_code/tools/output_compressor.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Tools
+    # Compresses tool output before it enters the conversation context.
+    # Each tool type has a strategy and threshold — outputs below the
+    # threshold pass through unchanged; larger outputs are compressed
+    # to keep context lean.
+    class OutputCompressor
+      CHARS_PER_TOKEN = 4
+
+      THRESHOLDS = {
+        'run_specs' => { max_tokens: 500, strategy: :spec_summary },
+        'bash' => { max_tokens: 1000, strategy: :head_tail },
+        'git_log' => { max_tokens: 800, strategy: :head_tail },
+        'git_diff' => { max_tokens: 2000, strategy: :relevant_hunks },
+        'grep' => { max_tokens: 1000, strategy: :top_matches },
+        'glob' => { max_tokens: 500,  strategy: :tree },
+        'git_status' => { max_tokens: 500, strategy: :head_tail },
+        'read_file' => { max_tokens: 3000, strategy: :head_tail }
+      }.freeze
+
+      DEFAULT_THRESHOLD = { max_tokens: 1500, strategy: :head_tail }.freeze
+
+      attr_reader :stats
+
+      def initialize
+        @stats = { calls: 0, compressed: 0, tokens_saved: 0 }
+      end
+
+      def compress(tool_name, raw_output)
+        return raw_output if raw_output.nil? || raw_output.empty?
+
+        @stats[:calls] += 1
+        config = THRESHOLDS.fetch(tool_name.to_s, DEFAULT_THRESHOLD)
+        max_chars = config[:max_tokens] * CHARS_PER_TOKEN
+
+        return raw_output if raw_output.length <= max_chars
+
+        compressed = apply_strategy(config[:strategy], raw_output, max_chars)
+        record_savings(raw_output, compressed)
+        compressed
+      end
+
+      private
+
+      def apply_strategy(strategy, output, max_chars)
+        case strategy
+        when :spec_summary   then compress_spec_output(output)
+        when :head_tail      then head_tail(output, max_chars)
+        when :relevant_hunks then compress_diff(output, max_chars)
+        when :top_matches    then top_matches(output, max_chars)
+        when :tree           then collapse_tree(output, max_chars)
+        end
+      end
+
+      def compress_spec_output(output)
+        lines = output.lines
+        summary_line = find_summary_line(lines)
+
+        return summary_line.strip if summary_line&.include?('0 failures')
+
+        failures = extract_spec_failures(lines)
+        return summary_line.strip if failures.empty? && summary_line
+
+        assemble_failure_report(failures, summary_line)
+      end
+
+      def find_summary_line(lines)
+        lines.reverse_each.find { |l| l.match?(/\d+ examples?/) }
+      end
+
+      def assemble_failure_report(failures, summary_line)
+        parts = []
+        parts.concat(failures.first(10))
+        parts << summary_line.strip if summary_line
+        remaining = failures.size - 10
+        parts << "(#{remaining} more failures omitted)" if remaining.positive?
+        parts.join("\n")
+      end
+
+      def extract_spec_failures(lines)
+        failures = []
+        capturing = false
+
+        lines.each do |line|
+          if line.match?(/^\s+\d+\)\s/) || line.match?(%r{^Failure/Error:})
+            capturing = true
+            failures << +''
+          end
+
+          if capturing
+            failures.last << line
+            capturing = false if line.strip.empty? && failures.last.length > 20
+          end
+        end
+
+        failures
+      end
+
+      # rubocop:disable Metrics/AbcSize -- head/tail splitting requires coordinated arithmetic
+      def head_tail(output, max_chars)
+        lines = output.lines
+        return output if lines.size <= 10
+
+        head_chars = (max_chars * 0.6).to_i
+        tail_chars = (max_chars * 0.3).to_i
+
+        head_lines = take_lines_up_to(lines, head_chars)
+        tail_lines = take_lines_up_to(lines.reverse, tail_chars).reverse
+        omitted = lines.size - head_lines.size - tail_lines.size
+
+        parts = [head_lines.join]
+        parts << "\n... [#{omitted} lines omitted] ...\n" if omitted.positive?
+        parts << tail_lines.join
+        parts.join
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      # rubocop:disable Metrics/AbcSize -- diff hunk iteration with header extraction
+      def compress_diff(output, max_chars)
+        hunks = output.split(/^(?=diff --git)/)
+        return head_tail(output, max_chars) if hunks.size <= 1
+
+        result = +''
+        hunks.each do |hunk|
+          header = hunk.lines.first(4).join
+          if result.length + hunk.length <= max_chars
+            result << hunk
+          else
+            result << header
+            result << "  ... (#{hunk.lines.size - 4} lines in this file omitted)\n"
+          end
+        end
+
+        result
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def top_matches(output, max_chars)
+        lines = output.lines
+        kept = take_lines_up_to(lines, max_chars)
+        omitted = lines.size - kept.size
+
+        result = kept.join
+        result << "\n... (#{omitted} more matches omitted)\n" if omitted.positive?
+        result
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity -- multi-step tree collapse
+      def collapse_tree(output, max_chars)
+        paths = output.lines.map(&:strip).reject(&:empty?)
+        return output if output.length <= max_chars
+
+        dirs = paths.map { |p| File.dirname(p) }.tally.sort_by { |_, c| -c }
+        result = dirs.map { |dir, count| "#{dir}/ (#{count} files)" }.join("\n")
+
+        return result if result.length <= max_chars
+
+        head_tail(result, max_chars)
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+
+      def take_lines_up_to(lines, max_chars)
+        taken = []
+        total = 0
+        lines.each do |line|
+          break if total + line.length > max_chars
+
+          taken << line
+          total += line.length
+        end
+        taken
+      end
+
+      def record_savings(original, compressed)
+        saved = (original.length - compressed.length) / CHARS_PER_TOKEN
+        return unless saved.positive?
+
+        @stats[:compressed] += 1
+        @stats[:tokens_saved] += saved
+      end
+    end
+  end
+end

data/lib/rubyn_code/tools/read_file.rb

@@ -19,17 +19,22 @@ module RubynCode
 
       def execute(path:, offset: nil, limit: nil)
         resolved = read_file_safely(path)
-
         lines = File.readlines(resolved)
+        start_line, end_line = compute_range(offset, limit, lines.length)
+        format_lines(lines[start_line...end_line] || [], start_line)
+      end
 
-        start_line = offset ? [offset.to_i - 1, 0].max : 0
-        end_line = limit ? start_line + limit.to_i : lines.length
+      private
 
-        selected = lines[start_line...end_line] || []
+      def compute_range(offset, limit, total)
+        start_line = offset ? [offset.to_i - 1, 0].max : 0
+        end_line = limit ? start_line + limit.to_i : total
+        [start_line, end_line]
+      end
 
+      def format_lines(selected, start_line)
         selected.each_with_index.map do |line, idx|
-          line_num = start_line + idx + 1
-          "#{line_num.to_s.rjust(6)}\t#{line}"
+          "#{(start_line + idx + 1).to_s.rjust(6)}\t#{line}"
         end.join
       end
     end

data/lib/rubyn_code/tools/review_pr.rb

@@ -8,8 +8,8 @@ module RubynCode
     class ReviewPr < Base
       TOOL_NAME = 'review_pr'
       DESCRIPTION = 'Review current branch changes against Ruby/Rails best practices. ' \
-                    'Gets the diff of the current branch vs the base branch, analyzes each changed file, ' \
-                    'and provides actionable suggestions with explanations.'
+                    'Gets the diff of the current branch vs the base branch, analyzes ' \
+                    'each changed file, and provides actionable suggestions with explanations.'
       PARAMETERS = {
         base_branch: {
           type: :string,
@@ -25,95 +25,138 @@ module RubynCode
       RISK_LEVEL = :read
 
       def execute(base_branch: 'main', focus: 'all')
-        # Check git is available
-        unless system('git rev-parse --is-inside-work-tree > /dev/null 2>&1', chdir: project_root)
-          return 'Error: Not a git repository or git is not installed.'
-        end
+        error = validate_git_repo
+        return error if error
+
+        current = current_branch_name
+        return current if current.start_with?('Error:')
+
+        base_branch, error = resolve_base(base_branch, current)
+        return error if error
+
+        diff = run_git("diff #{base_branch}...HEAD")
+        return "No changes found between #{current} and #{base_branch}." if diff.strip.empty?
+
+        build_full_review(current, base_branch, diff, focus)
+      end
+
+      FILE_CATEGORIES = [
+        ['Ruby',       /\.(rb|rake|gemspec|ru)$/],
+        ['Templates',  /\.(erb|haml|slim)$/],
+        ['Specs',      /_spec\.rb$|_test\.rb$/],
+        ['Migrations', %r{db/migrate}],
+        ['Config',     %r{config/|\.ya?ml$}]
+      ].freeze
+
+      private
 
-        # Get current branch
+      def validate_git_repo
+        return nil if system(
+          'git rev-parse --is-inside-work-tree > /dev/null 2>&1',
+          chdir: project_root
+        )
+
+        'Error: Not a git repository or git is not installed.'
+      end
+
+      def current_branch_name
         current = run_git('rev-parse --abbrev-ref HEAD').strip
         return 'Error: Could not determine current branch.' if current.empty?
 
+        current
+      end
+
+      def resolve_base(base_branch, current)
         if current == base_branch
-          return "You're on #{base_branch}. Switch to a feature branch first, or specify a different base: review_pr(base_branch: 'develop')"
+          return [nil, "You're on #{base_branch}. Switch to a feature branch " \
+                       "or specify a different base: review_pr(base_branch: 'develop')"]
         end
 
-        # Check base branch exists
-        unless run_git("rev-parse --verify #{base_branch} 2>/dev/null").strip.length.positive?
-          # Try origin/main
-          base_branch = "origin/#{base_branch}"
-          unless run_git("rev-parse --verify #{base_branch} 2>/dev/null").strip.length.positive?
-            return "Error: Base branch '#{base_branch}' not found."
-          end
-        end
+        return [base_branch, nil] if branch_exists?(base_branch)
 
-        # Get the diff
-        diff = run_git("diff #{base_branch}...HEAD")
-        return "No changes found between #{current} and #{base_branch}." if diff.strip.empty?
+        origin = "origin/#{base_branch}"
+        return [origin, nil] if branch_exists?(origin)
+
+        [nil, "Error: Base branch '#{base_branch}' not found."]
+      end
 
-        # Get changed files with stats
+      def build_full_review(current, base_branch, diff, focus)
+        review = build_review_header(current, base_branch)
+        review.concat(build_file_categories(base_branch))
+        review.concat(build_focus_section(focus))
+        review.concat(build_diff_section(diff))
+        review.concat(build_review_checklist)
+        truncate(review.join("\n"))
+      end
+
+      def branch_exists?(branch)
+        run_git("rev-parse --verify #{branch} 2>/dev/null").strip.length.positive?
+      end
+
+      def build_review_header(current, base_branch)
         stat = run_git("diff #{base_branch}...HEAD --stat")
-        files_changed = run_git("diff #{base_branch}...HEAD --name-only").strip.split("\n")
         commit_log = run_git("log #{base_branch}..HEAD --oneline")
 
-        # Build the review context
-        ruby_files = files_changed.grep(/\.(rb|rake|gemspec|ru)$/)
-        erb_files = files_changed.grep(/\.(erb|haml|slim)$/)
-        spec_files = files_changed.grep(/_spec\.rb$|_test\.rb$/)
-        migration_files = files_changed.select { |f| f.include?('db/migrate') }
-        config_files = files_changed.grep(%r{config/|\.yml$|\.yaml$})
+        [
+          "# PR Review: #{current} -> #{base_branch}",
+          '',
+          '## Summary',
+          stat,
+          '',
+          '## Commits',
+          commit_log,
+          ''
+        ]
+      end
 
-        review = []
-        review << "# PR Review: #{current} → #{base_branch}"
-        review << ''
-        review << '## Summary'
-        review << stat
-        review << ''
-        review << '## Commits'
-        review << commit_log
-        review << ''
-        review << '## Files by Category'
-        review << "- Ruby: #{ruby_files.length} files" unless ruby_files.empty?
-        review << "- Templates: #{erb_files.length} files" unless erb_files.empty?
-        review << "- Specs: #{spec_files.length} files" unless spec_files.empty?
-        review << "- Migrations: #{migration_files.length} files" unless migration_files.empty?
-        review << "- Config: #{config_files.length} files" unless config_files.empty?
+      def build_file_categories(base_branch)
+        files = run_git("diff #{base_branch}...HEAD --name-only").strip.split("\n")
+        review = ['## Files by Category']
+        FILE_CATEGORIES.each do |label, pattern|
+          review << "- #{label}: #{files.grep(pattern).length} files"
+        end
         review << ''
+        review
+      end
 
-        # Add focus-specific review instructions
-        review << "## Review Focus: #{focus.upcase}"
-        review << review_instructions(focus)
-        review << ''
+      def build_focus_section(focus)
+        [
+          "## Review Focus: #{focus.upcase}",
+          review_instructions(focus),
+          ''
+        ]
+      end
 
-        # Add the diff (truncated if too large)
+      def build_diff_section(diff)
         if diff.length > 40_000
-          review << "## Diff (truncated — #{diff.length} chars total)"
-          review << diff[0...40_000]
-          review << "\n... [truncated #{diff.length - 40_000} chars]"
+          [
+            "## Diff (truncated — #{diff.length} chars total)",
+            diff[0...40_000],
+            "\n... [truncated #{diff.length - 40_000} chars]"
+          ]
         else
-          review << '## Full Diff'
-          review << diff
+          ['## Full Diff', diff]
         end
-
-        review << ''
-        review << '---'
-        review << 'Review this diff against Ruby/Rails best practices. For each issue found:'
-        review << '1. Quote the specific code'
-        review << "2. Explain what's wrong and WHY it matters"
-        review << '3. Show the suggested fix'
-        review << '4. Rate severity: [critical] [warning] [suggestion] [nitpick]'
-        review << ''
-        review << 'Also check for:'
-        review << '- Missing tests for new code'
-        review << '- N+1 queries in ActiveRecord changes'
-        review << '- Security issues (SQL injection, XSS, mass assignment)'
-        review << '- Missing database indexes for new associations'
-        review << '- Proper error handling'
-
-        truncate(review.join("\n"))
       end
 
-      private
+      def build_review_checklist
+        [
+          '',
+          '---',
+          'Review this diff against Ruby/Rails best practices. For each issue found:',
+          '1. Quote the specific code',
+          "2. Explain what's wrong and WHY it matters",
+          '3. Show the suggested fix',
+          '4. Rate severity: [critical] [warning] [suggestion] [nitpick]',
+          '',
+          'Also check for:',
+          '- Missing tests for new code',
+          '- N+1 queries in ActiveRecord changes',
+          '- Security issues (SQL injection, XSS, mass assignment)',
+          '- Missing database indexes for new associations',
+          '- Proper error handling'
+        ]
+      end
 
       def run_git(command)
         `cd #{project_root} && git #{command} 2>/dev/null`
@@ -122,20 +165,24 @@ module RubynCode
       def review_instructions(focus)
         case focus.to_s.downcase
         when 'security'
-          'Focus on: SQL injection, XSS, CSRF, mass assignment, authentication/authorization gaps, ' \
-          'sensitive data exposure, insecure dependencies, command injection, path traversal.'
+          'Focus on: SQL injection, XSS, CSRF, mass assignment, ' \
+          'authentication/authorization gaps, sensitive data exposure, ' \
+          'insecure dependencies, command injection, path traversal.'
         when 'performance'
-          'Focus on: N+1 queries, missing indexes, eager loading, caching opportunities, ' \
-          'unnecessary database calls, memory bloat, slow iterations, missing pagination.'
+          'Focus on: N+1 queries, missing indexes, eager loading, caching ' \
+          'opportunities, unnecessary database calls, memory bloat, slow ' \
+          'iterations, missing pagination.'
         when 'style'
-          'Focus on: Ruby idioms, naming conventions, method length, class organization, ' \
-          'frozen string literals, guard clauses, DRY violations, dead code.'
+          'Focus on: Ruby idioms, naming conventions, method length, class ' \
+          'organization, frozen string literals, guard clauses, DRY ' \
+          'violations, dead code.'
         when 'testing'
-          'Focus on: Missing test coverage, test quality, factory usage, assertion quality, ' \
-          'test isolation, flaky test risks, edge cases, integration vs unit test balance.'
+          'Focus on: Missing test coverage, test quality, factory usage, ' \
+          'assertion quality, test isolation, flaky test risks, edge ' \
+          'cases, integration vs unit test balance.'
         else
-          'Review all aspects: code quality, security, performance, testing, Rails conventions, ' \
-          'Ruby idioms, and architectural patterns.'
+          'Review all aspects: code quality, security, performance, testing, ' \
+          'Rails conventions, Ruby idioms, and architectural patterns.'
         end
       end
     end

data/lib/rubyn_code/tools/run_specs.rb

@@ -10,10 +10,18 @@ module RubynCode
       TOOL_NAME = 'run_specs'
       DESCRIPTION = 'Runs RSpec or Minitest specs. Auto-detects which test framework is in use.'
       PARAMETERS = {
-        path: { type: :string, required: false, description: 'Specific test file or directory to run' },
-        format: { type: :string, required: false, default: 'documentation',
-                  description: "Output format (default: 'documentation')" },
-        fail_fast: { type: :boolean, required: false, description: 'Stop on first failure' }
+        path: {
+          type: :string, required: false,
+          description: 'Specific test file or directory to run'
+        },
+        format: {
+          type: :string, required: false, default: 'documentation',
+          description: "Output format (default: 'documentation')"
+        },
+        fail_fast: {
+          type: :boolean, required: false,
+          description: 'Stop on first failure'
+        }
       }.freeze
       RISK_LEVEL = :execute
       REQUIRES_CONFIRMATION = false
@@ -30,14 +38,21 @@ module RubynCode
       private
 
       def detect_framework
+        detect_from_gemfile || detect_from_files
+      end
+
+      def detect_from_gemfile
         gemfile_path = File.join(project_root, 'Gemfile')
+        return nil unless File.exist?(gemfile_path)
 
-        if File.exist?(gemfile_path)
-          content = File.read(gemfile_path)
-          return :rspec if content.match?(/['"]rspec['"]/) || content.match?(/['"]rspec-rails['"]/)
-          return :minitest if content.match?(/['"]minitest['"]/)
-        end
+        content = File.read(gemfile_path)
+        return :rspec if content.match?(/['"]rspec['"]/) || content.match?(/['"]rspec-rails['"]/)
+        return :minitest if content.match?(/['"]minitest['"]/)
+
+        nil
+      end
 
+      def detect_from_files
         return :rspec if File.exist?(File.join(project_root, '.rspec'))
         return :rspec if File.directory?(File.join(project_root, 'spec'))
         return :minitest if File.directory?(File.join(project_root, 'test'))
@@ -54,17 +69,13 @@ module RubynCode
           cmd += " #{path}" if path
           cmd
         when :minitest
-          if path
-            "bundle exec ruby -Itest #{path}"
-          else
-            'bundle exec rails test'
-          end
+          path ? "bundle exec ruby -Itest #{path}" : 'bundle exec rails test'
         end
       end
 
       def build_output(stdout, stderr, status)
         parts = []
-        parts << stdout unless stdout.empty?
+        parts << SpecOutputParser.parse(stdout) unless stdout.empty?
         parts << "STDERR:\n#{stderr}" unless stderr.empty?
         parts << "Exit code: #{status.exitstatus}" unless status.success?
         parts.empty? ? '(no output)' : parts.join("\n")

data/lib/rubyn_code/tools/schema.rb

@@ -35,20 +35,14 @@ module RubynCode
           schema
         end
 
+        OPTIONAL_PROP_KEYS = %i[description default enum].freeze
+
         private
 
         def build_property(spec)
-          prop = {}
-
-          type = spec[:type] || :string
-          prop[:type] = TYPE_MAP.fetch(type, type.to_s)
-
-          prop[:description] = spec[:description] if spec[:description]
-          prop[:default] = spec[:default] if spec.key?(:default)
-          prop[:enum] = spec[:enum] if spec[:enum]
-
+          prop = { type: TYPE_MAP.fetch(spec[:type] || :string, (spec[:type] || :string).to_s) }
+          OPTIONAL_PROP_KEYS.each { |key| prop[key] = spec[key] if spec.key?(key) && spec[key] }
           prop[:items] = build_property(spec[:items]) if spec[:items]
-
           prop
         end
       end