rubocop-claude 0.1.0

data/lib/rubocop/cop/claude/no_overly_defensive_code.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Claude
+      # Flags overly defensive coding patterns.
+      #
+      # AI assistants often add excessive error handling and nil-checking
+      # "just in case." This obscures bugs and indicates distrust of the codebase.
+      #
+      # @example Error swallowing (flagged)
+      #   # bad
+      #   begin; do_something; rescue => e; nil; end
+      #   result = do_something rescue nil
+      #
+      # @example Excessive safe navigation (flagged)
+      #   # bad - 2+ chained &.
+      #   user&.profile&.settings
+      #
+      # @example Defensive nil checks (flagged)
+      #   # bad
+      #   a && a.foo
+      #   a.present? && a.foo
+      #   foo.nil? ? default : foo
+      #   foo ? foo : default
+      #
+      class NoOverlyDefensiveCode < Base
+        extend AutoCorrector
+
+        MSG_SWALLOW = "Trust internal code. Don't swallow errors with `rescue nil` or `rescue => e; nil`."
+        MSG_CHAIN = 'Trust internal code. Excessive safe navigation (%<count>d chained `&.`) suggests ' \
+                    'uncertain data model. Use explicit nil checks or fix the source.'
+        MSG_NIL_CHECK = 'Trust internal code. `%<code>s` is a defensive nil check. ' \
+                        'Use `%<replacement>s` instead.'
+        MSG_NIL_TERNARY = 'Trust internal code. `%<code>s` is a verbose nil check. ' \
+                          'Use `%<replacement>s` instead.'
+        MSG_INVERSE_TERNARY = 'Trust internal code. `%<code>s` is verbose. ' \
+                              'Use `%<replacement>s` instead.'
+        MSG_PRESENT_CHECK = 'Trust internal code. `%<code>s` is a defensive presence check. ' \
+                            'Use `%<replacement>s` instead.'
+
+        BROAD_EXCEPTIONS = %w[Exception StandardError RuntimeError].freeze
+
+        def on_resbody(node)
+          add_offense(node, message: MSG_SWALLOW) if swallows_error?(node)
+        end
+
+        def on_and(node)
+          left, right = *node
+          return unless right.send_type?
+
+          check_presence_pattern(node, left, right) || check_nil_check_pattern(node, left, right)
+        end
+
+        def on_if(node)
+          return unless node.ternary?
+
+          condition, if_branch, else_branch = *node
+          check_nil_ternary(node, condition, if_branch, else_branch) ||
+            check_inverse_ternary(node, condition, if_branch, else_branch)
+        end
+
+        def on_csend(node)
+          return if node.parent&.csend_type?
+
+          chain_length = count_safe_nav_chain(node)
+          return unless chain_length > max_safe_navigation_chain
+
+          add_offense(node, message: format(MSG_CHAIN, count: chain_length))
+        end
+
+        private
+
+        # Pattern: `a.present? && a.foo` -> `a.foo`
+        def check_presence_pattern(node, left, right)
+          return unless left.send_type? && left.method_name == :present?
+          return unless same_variable?(left.receiver, right.receiver)
+
+          register_offense(node, build_replacement(right), MSG_PRESENT_CHECK)
+        end
+
+        # Pattern: `a && a.foo` -> `a.foo`
+        def check_nil_check_pattern(node, left, right)
+          return unless right.receiver && same_variable?(left, right.receiver)
+
+          register_offense(node, build_replacement(right), MSG_NIL_CHECK)
+        end
+
+        # Pattern: `foo.nil? ? default : foo` -> `foo || default`
+        def check_nil_ternary(node, condition, if_branch, else_branch)
+          return unless condition.send_type? && %i[nil? blank?].include?(condition.method_name)
+          return unless same_variable?(condition.receiver, else_branch)
+
+          register_offense(node, "#{condition.receiver.source} || #{if_branch.source}", MSG_NIL_TERNARY)
+        end
+
+        # Pattern: `foo ? foo : default` -> `foo || default`
+        def check_inverse_ternary(node, condition, if_branch, else_branch)
+          return unless same_variable?(condition, if_branch)
+
+          register_offense(node, "#{condition.source} || #{else_branch.source}", MSG_INVERSE_TERNARY)
+        end
+
+        def register_offense(node, replacement, msg_template)
+          message = format(msg_template, code: node.source, replacement: replacement)
+          add_offense(node, message: message) { |corrector| corrector.replace(node, replacement) }
+        end
+
+        def swallows_error?(resbody_node)
+          exception_type, _var, body = *resbody_node
+          return false if exception_type && specific_exception?(exception_type)
+
+          body.nil? || body.nil_type? || empty_return?(body)
+        end
+
+        def empty_return?(body)
+          body.return_type? && (body.children.empty? || body.children.first.nil_type?)
+        end
+
+        def specific_exception?(exception_node)
+          exception_node.children.all? { |c| specific_exception_class?(c) }
+        end
+
+        def specific_exception_class?(const_node)
+          const_node.const_type? && !BROAD_EXCEPTIONS.include?(const_node.children.last.to_s)
+        end
+
+        def count_safe_nav_chain(node)
+          count = 1
+          current = node.receiver
+          while current.csend_type?
+            count += 1
+            current = current.receiver
+          end
+          count
+        end
+
+        def same_variable?(node1, node2)
+          node1 && node2 && node1.source == node2.source
+        end
+
+        def build_replacement(send_node)
+          return send_node.source unless add_safe_navigator?
+
+          args = send_node.arguments.map(&:source).join(', ')
+          base = "#{send_node.receiver.source}&.#{send_node.method_name}"
+          send_node.arguments.empty? ? base : "#{base}(#{args})"
+        end
+
+        def add_safe_navigator?
+          @add_safe_navigator ||= cop_config.fetch('AddSafeNavigator', false)
+        end
+
+        def max_safe_navigation_chain
+          @max_safe_navigation_chain ||= cop_config.fetch('MaxSafeNavigationChain', 1)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/claude/tagged_comments.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Claude
+      # Enforces attribution on TODO/NOTE/FIXME/HACK comments.
+      #
+      # Anonymous TODO comments lose context over time. Who wrote it?
+      # When? What was the context? Attribution helps track ownership
+      # and distinguishes human-written comments from AI-generated ones.
+      #
+      # @example Default (attribution required)
+      #   # bad
+      #   # TODO: Fix this later
+      #   # FIXME: Handle edge case
+      #
+      #   # good - handle format (after colon, compatible with Style/CommentAnnotation)
+      #   # TODO: [@username] Fix this later
+      #   # FIXME: [Alice - @alice] Handle edge case
+      #
+      # @example Case insensitive (keywords matched regardless of case)
+      #   # bad
+      #   # todo: fix this
+      #   # Todo: Fix this
+      #
+      # @example AI assistant attribution
+      #   # good - AI-generated comments use @claude
+      #   # TODO: [@claude] Refactor to reduce complexity
+      #   # NOTE: [@claude] This pattern matches the factory in user.rb
+      #
+      # @example Keywords: ['TODO', 'FIXME'] (custom keyword list)
+      #   # With custom keywords, only those are checked
+      #   # bad - TODO is in the list
+      #   # TODO: Fix this
+      #
+      #   # good - NOTE not in the custom list, so not checked
+      #   # NOTE: No attribution needed
+      #
+      # @example Valid attribution formats
+      #   [@handle]              # Just handle
+      #   [Name - @handle]       # Name and handle
+      #   [First Last - @handle] # Full name and handle
+      #
+      class TaggedComments < Base
+        MSG = 'Comments need attribution. Use format: # %<keyword>s: [@handle] description'
+
+        ATTRIBUTION_PATTERN = /\[(?:[\w\s]+-\s*)?@[\w-]+\]/
+
+        def on_new_investigation
+          processed_source.comments.each do |comment|
+            check_comment(comment)
+          end
+        end
+
+        private
+
+        def check_comment(comment)
+          text = comment.text
+          match = text.match(keyword_regex)
+          return unless match
+
+          keyword = match[1].upcase
+          return if text.match?(ATTRIBUTION_PATTERN)
+
+          add_offense(comment, message: format(MSG, keyword: keyword))
+        end
+
+        def keyword_regex
+          @keyword_regex ||= begin
+            keywords = cop_config.fetch('Keywords', %w[TODO FIXME NOTE HACK OPTIMIZE REVIEW])
+            pattern_str = "\\A#\\s*(#{keywords.join("|")}):?\\s+(?!\\[[@\\w])"
+            Regexp.new(pattern_str, Regexp::IGNORECASE)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop-claude.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+require_relative 'rubocop_claude/version'
+require_relative 'rubocop_claude/plugin'
+
+require_relative 'rubocop/cop/claude/no_fancy_unicode'
+require_relative 'rubocop/cop/claude/tagged_comments'
+require_relative 'rubocop/cop/claude/no_commented_code'
+require_relative 'rubocop/cop/claude/no_backwards_compat_hacks'
+require_relative 'rubocop/cop/claude/no_overly_defensive_code'
+require_relative 'rubocop/cop/claude/explicit_visibility'
+require_relative 'rubocop/cop/claude/mystery_regex'
+require_relative 'rubocop/cop/claude/no_hardcoded_line_numbers'
+
+module RubocopClaude
+  class Error < StandardError; end
+end

data/lib/rubocop_claude/cli.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'yaml'
+require_relative 'version'
+require_relative 'init_wizard/hooks_installer'
+require_relative 'init_wizard/linter_configurer'
+require_relative 'init_wizard/preferences_gatherer'
+
+module RubocopClaude
+  # CLI for rubocop-claude commands
+  class CLI
+    TEMPLATES_DIR = File.expand_path('../../templates', __dir__).freeze
+
+    def self.run(args)
+      new.run(args)
+    end
+
+    def run(args)
+      case args.first
+      when 'init' then InitWizard.new.run
+      when 'version', '-v', '--version' then puts "rubocop-claude #{VERSION}"
+      when 'help', '-h', '--help', nil then print_help
+      else
+        warn "Unknown command: #{args.first}"
+        print_help
+        exit 1
+      end
+    end
+
+    private
+
+    def print_help
+      puts <<~HELP
+        Usage: rubocop-claude <command>
+
+        Commands:
+          init      Interactive setup wizard
+          version   Show version
+          help      Show this help
+
+        Examples:
+          rubocop-claude init     # Set up rubocop-claude in current project
+          rubocop-claude version  # Show version
+      HELP
+    end
+  end
+
+  # Interactive setup wizard for rubocop-claude
+  class InitWizard
+    TEMPLATES_DIR = CLI::TEMPLATES_DIR
+    DEVELOPMENT_GROUP_PATTERN = /group\s+:development.*do/m
+    DEVELOPMENT_GROUP_CAPTURE = /^(\s*)(group\s+:development.*?do\s*$)/m
+
+    attr_accessor :using_standard, :install_hooks, :hook_linter
+
+    def initialize
+      @changes = []
+      @config_overrides = {}
+      @using_standard = false
+      @install_hooks = false
+      @hook_linter = 'rubocop'
+    end
+
+    def run
+      print_welcome
+      check_gemfile
+      LinterConfigurer.new(self).run
+      PreferencesGatherer.new(self).run
+      create_claude_files
+      print_summary
+    end
+
+    def add_change(description)
+      @changes << description
+    end
+
+    def add_config_override(cop, settings)
+      @config_overrides[cop] = settings
+    end
+
+    def prompt_yes?(question, default:)
+      suffix = default ? '[Y/n]' : '[y/N]'
+      print "#{question} #{suffix} "
+
+      answer = $stdin.gets
+      return default if answer.nil?
+
+      normalized = answer.strip.downcase
+      return default if normalized.empty?
+
+      normalized == 'y'
+    end
+
+    def prompt_choice(question, options, default:)
+      options_str = options.map { |k, v| "#{k}=#{v}" }.join(', ')
+      print "#{question} (#{options_str}) [#{default}] "
+
+      answer = $stdin.gets
+      return default if answer.nil?
+
+      normalized = answer.strip.downcase
+      return default if normalized.empty?
+
+      options.key?(normalized) ? normalized : default
+    end
+
+    def load_yaml(file)
+      return {} unless File.exist?(file)
+
+      YAML.load_file(file) || {}
+    end
+
+    def save_yaml(file, data)
+      File.write(file, YAML.dump(data))
+    end
+
+    private
+
+    def print_welcome
+      puts <<~WELCOME
+        +-------------------------------------------+
+        |  rubocop-claude #{VERSION.ljust(26)}|
+        |  AI-focused Ruby linting setup wizard     |
+        +-------------------------------------------+
+
+      WELCOME
+    end
+
+    def check_gemfile
+      return unless File.exist?('Gemfile')
+
+      gemfile_content = File.read('Gemfile')
+      return if gemfile_content.include?('rubocop-claude')
+      return unless prompt_yes?('Add rubocop-claude to Gemfile?', default: true)
+
+      add_to_gemfile
+    end
+
+    def add_to_gemfile
+      gemfile = File.read('Gemfile')
+      File.write('Gemfile', insert_gem_into_gemfile(gemfile))
+      @changes << 'Added rubocop-claude to Gemfile'
+      puts '  Added to Gemfile (run `bundle install`)'
+      puts
+    end
+
+    def insert_gem_into_gemfile(content)
+      gem_line = "gem 'rubocop-claude', require: false"
+      return content + "\n#{gem_line}\n" unless content.match?(DEVELOPMENT_GROUP_PATTERN)
+
+      content.sub(DEVELOPMENT_GROUP_CAPTURE) do
+        "#{::Regexp.last_match(1)}#{::Regexp.last_match(2)}\n#{::Regexp.last_match(1)}  #{gem_line}"
+      end
+    end
+
+    def create_claude_files
+      puts 'Claude integration files:'
+      puts
+
+      create_claude_directory
+      create_linting_md
+      create_cop_guides
+      create_local_config
+      create_hooks if @install_hooks
+    end
+
+    def create_claude_directory
+      return if Dir.exist?('.claude')
+
+      FileUtils.mkdir_p('.claude')
+      puts '  Created .claude/ directory'
+    end
+
+    def create_linting_md
+      dest = '.claude/linting.md'
+      source = File.join(TEMPLATES_DIR, 'linting.md')
+
+      if File.exist?(dest)
+        return unless prompt_yes?("  #{dest} exists. Overwrite?", default: false)
+      end
+
+      FileUtils.cp(source, dest)
+      @changes << 'Created .claude/linting.md'
+      puts "  Created #{dest}"
+    end
+
+    def create_cop_guides
+      cops_dir = '.claude/cops'
+      FileUtils.mkdir_p(cops_dir)
+
+      source_dir = File.join(TEMPLATES_DIR, 'cops')
+      cop_files = Dir.glob(File.join(source_dir, '*.md'))
+
+      cop_files.each { |src| FileUtils.cp(src, cops_dir) }
+      @changes << "Created .claude/cops/ (#{cop_files.size} guides)"
+      puts "  Created #{cops_dir}/ (#{cop_files.size} cop guides)"
+    end
+
+    def create_local_config
+      overrides = build_config_overrides
+      dest = '.rubocop_claude.yml'
+      save_yaml(dest, merge_with_existing(dest, overrides))
+      @changes << 'Created .rubocop_claude.yml with your preferences'
+      puts "  Created #{dest}"
+      puts '  (Add `inherit_from: .rubocop_claude.yml` to your rubocop config)'
+    end
+
+    def build_config_overrides
+      overrides = @config_overrides.dup
+      overrides.delete('inherit_from_ai_defaults')
+      overrides
+    end
+
+    def merge_with_existing(file, overrides)
+      return overrides unless File.exist?(file)
+
+      load_yaml(file).merge(overrides)
+    end
+
+    def create_hooks
+      HooksInstaller.new(self).run
+    end
+
+    def print_summary
+      puts '', '-' * 45, 'Setup complete!', ''
+      print_changes
+      print_next_steps
+    end
+
+    def print_changes
+      puts 'Changes made:'
+      @changes.each { |c| puts "  - #{c}" }
+      puts
+    end
+
+    def print_next_steps
+      puts <<~STEPS
+        Next steps:
+          1. Run `bundle install` if Gemfile was updated
+          2. Run `standardrb` or `rubocop` to lint your code
+          3. Add .claude/linting.md to your AI assistant context
+      STEPS
+    end
+  end
+end

data/lib/rubocop_claude/generator.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module RubocopClaude
+  class Generator
+    TEMPLATES_DIR = File.expand_path('../../templates', __dir__).freeze
+
+    def initialize(project_root)
+      @project_root = project_root
+    end
+
+    def run
+      ensure_directories
+      copy_linting_guide
+      copy_cop_guides
+      update_standard_yml if standard_yml_exists?
+      print_summary
+    end
+
+    private
+
+    def ensure_directories
+      FileUtils.mkdir_p(claude_directory)
+      FileUtils.mkdir_p(cops_directory)
+    end
+
+    def claude_directory
+      File.join(@project_root, '.claude')
+    end
+
+    def cops_directory
+      File.join(claude_directory, 'cops')
+    end
+
+    def copy_linting_guide
+      src = File.join(TEMPLATES_DIR, 'linting.md')
+      dest = File.join(claude_directory, 'linting.md')
+      FileUtils.cp(src, dest)
+      puts "Created #{relative_path(dest)}"
+    end
+
+    def copy_cop_guides
+      cops_src_dir = File.join(TEMPLATES_DIR, 'cops')
+      Dir.glob(File.join(cops_src_dir, '*.md')).each do |src|
+        filename = File.basename(src)
+        dest = File.join(cops_directory, filename)
+        FileUtils.cp(src, dest)
+        puts "Created #{relative_path(dest)}"
+      end
+    end
+
+    def standard_yml_exists?
+      File.exist?(standard_yml_path)
+    end
+
+    def standard_yml_path
+      File.join(@project_root, '.standard.yml')
+    end
+
+    def update_standard_yml
+      content = File.read(standard_yml_path)
+      return puts "#{relative_path(standard_yml_path)} already includes rubocop-claude" if content.include?('rubocop-claude')
+
+      File.write(standard_yml_path, add_plugin_to_yaml(content))
+      puts "Updated #{relative_path(standard_yml_path)} to include rubocop-claude plugin"
+    end
+
+    def add_plugin_to_yaml(content)
+      return content.sub(/^(plugins:)\n/, "\\1\n  - rubocop-claude\n") if content.include?('plugins:')
+
+      content.rstrip + "\n\nplugins:\n  - rubocop-claude\n"
+    end
+
+    def print_summary
+      puts '', 'rubocop-claude initialized!', ''
+      puts 'Files created:'
+      puts '  .claude/linting.md          - Main linting instructions'
+      puts '  .claude/cops/*.md           - Per-cop fix guidance (loaded on-demand)'
+      puts '', 'Next steps:'
+      puts "  1. Add `gem 'rubocop-claude'` to your Gemfile"
+      puts '  2. Run `bin/standardrb` to check for issues'
+      puts '', 'When Claude hits a lint error, it reads the relevant cop guide for fix instructions.'
+    end
+
+    def relative_path(path)
+      path.sub("#{@project_root}/", '')
+    end
+  end
+end