ruby-ai-gem-context 0.1.0

data/lib/ruby_ai_gem_context/generator.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "ruby_llm"
+
+module RubyAiGemContext
+  # Generates context files using RubyLLM
+  class Generator
+    attr_reader :platform, :file_collector, :options
+
+    # @param platform [Class] Platform class (e.g., Platforms::Claude)
+    # @param file_collector [FileCollector] Collector with project files
+    # @param options [Hash] Additional options
+    def initialize(platform:, file_collector:, **options)
+      @platform = platform
+      @file_collector = file_collector
+      @options = options
+    end
+
+    # Generate content for the platform
+    # @return [String] Generated content
+    def generate
+      files = file_collector.collect
+      prompt = build_prompt(files)
+
+      response = chat(prompt)
+      response.content
+    end
+
+    # Build the full prompt including project context
+    def build_prompt(files)
+      <<~PROMPT
+        #{platform.generation_prompt}
+
+        ---
+
+        Here is the project's source code and files for context:
+
+        #{format_files(files)}
+      PROMPT
+    end
+
+    private
+
+    def chat(prompt)
+      model = options[:model] || RubyAiGemContext.configuration.model
+
+      RubyLLM.chat(
+        model: model,
+        messages: [{ role: "user", content: prompt }],
+        temperature: RubyAiGemContext.configuration.temperature,
+        max_tokens: RubyAiGemContext.configuration.max_tokens
+      )
+    end
+
+    def format_files(files)
+      files.map do |path, content|
+        <<~FILE
+          ### #{path}
+
+          ```#{language_for(path)}
+          #{truncate_content(content)}
+          ```
+        FILE
+      end.join("\n")
+    end
+
+    def language_for(path)
+      case File.extname(path)
+      when ".rb" then "ruby"
+      when ".rake" then "ruby"
+      when ".gemspec" then "ruby"
+      when ".yml", ".yaml" then "yaml"
+      when ".json" then "json"
+      when ".md" then "markdown"
+      when ".txt" then "text"
+      else ""
+      end
+    end
+
+    def truncate_content(content, max_lines: 200)
+      lines = content.lines
+      if lines.size > max_lines
+        lines.first(max_lines).join + "\n# ... (truncated, #{lines.size - max_lines} more lines)"
+      else
+        content
+      end
+    end
+  end
+end

data/lib/ruby_ai_gem_context/interactive.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+require "tty-spinner"
+
+module RubyAiGemContext
+  # Interactive terminal UI for rake tasks
+  class Interactive
+    attr_reader :prompt, :project_root
+
+    def initialize(project_root = Dir.pwd)
+      @prompt = TTY::Prompt.new
+      @project_root = project_root
+    end
+
+    # === Setup Task ===
+
+    # Ask which platforms to generate boilerplate for
+    def select_platforms
+      choices = RubyAiGemContext::PLATFORMS.map do |key, platform_class|
+        { name: "#{platform_class.name} (#{platform_class.filename})", value: key }
+      end
+
+      prompt.multi_select(
+        "Which platforms do you want to generate context files for?",
+        choices,
+        help: "(Use space to select, enter to confirm)",
+        min: 1
+      )
+    end
+
+    # Handle collision when file exists
+    def handle_collision(platform_class)
+      prompt.select(
+        "#{platform_class.filename} already exists. What would you like to do?",
+        [
+          { name: "Skip (keep existing)", value: :skip },
+          { name: "Backup & overwrite (saves #{platform_class.filename}.backup)", value: :backup },
+          { name: "Show diff (compare before deciding)", value: :diff },
+          { name: "Overwrite (replace existing)", value: :overwrite }
+        ]
+      )
+    end
+
+    # Show diff between existing and new content
+    def show_diff(existing, new_content)
+      puts "\n--- Existing content ---"
+      puts existing.lines.first(20).join
+      puts "..." if existing.lines.size > 20
+      puts "\n--- New content ---"
+      puts new_content.lines.first(20).join
+      puts "..." if new_content.lines.size > 20
+      puts
+
+      prompt.select("What would you like to do?", [
+        { name: "Keep existing", value: :skip },
+        { name: "Use new content", value: :overwrite },
+        { name: "Backup & use new", value: :backup }
+      ])
+    end
+
+    # === Generate Task ===
+
+    # Ask about source folders
+    def select_source_folders
+      choice = prompt.select(
+        "Where should we read source files from?",
+        [
+          { name: "Project root (scan everything)", value: :root },
+          { name: "Specific folders (you'll provide a list)", value: :specific }
+        ]
+      )
+
+      case choice
+      when :root
+        nil # nil means scan from root
+      when :specific
+        ask_folder_list
+      end
+    end
+
+    # Ask for specific folder list
+    def ask_folder_list
+      input = prompt.ask(
+        "Enter folder paths (comma-separated, relative to project root):",
+        default: "lib, app"
+      )
+
+      input.split(",").map(&:strip).reject(&:empty?)
+    end
+
+    # Confirm source folders and show what will be scanned
+    def confirm_source_folders(folders, summary)
+      puts
+      puts "Will scan #{summary[:total_files]} files (#{format_size(summary[:total_size])})"
+      puts "File types: #{summary[:by_extension].map { |ext, count| "#{ext || 'no ext'}: #{count}" }.join(', ')}"
+      puts
+
+      prompt.yes?("Proceed with generation?")
+    end
+
+    # Select which existing platforms to regenerate
+    def select_platforms_to_regenerate(existing_platforms)
+      choices = existing_platforms.map do |key|
+        platform_class = RubyAiGemContext.platform(key)
+        { name: "#{platform_class.name} (#{platform_class.filename})", value: key }
+      end
+
+      prompt.multi_select(
+        "Which context files do you want to regenerate?",
+        choices,
+        help: "(Use space to select, enter to confirm)"
+      )
+    end
+
+    # === Generate for Gem Task ===
+
+    # Ask for gem name
+    def ask_gem_name
+      prompt.ask("Enter the gem name:") do |q|
+        q.required true
+        q.validate(/\A[\w-]+\z/, "Invalid gem name format")
+      end
+    end
+
+    # === Progress Indicators ===
+
+    # Show spinner while doing work
+    def with_spinner(message)
+      spinner = TTY::Spinner.new("[:spinner] #{message}", format: :dots)
+      spinner.auto_spin
+      result = yield
+      spinner.success("Done!")
+      result
+    rescue StandardError => e
+      spinner.error("Failed!")
+      raise e
+    end
+
+    # === Output Helpers ===
+
+    def success(message)
+      puts prompt.decorate("✓ #{message}", :green)
+    end
+
+    def warning(message)
+      puts prompt.decorate("⚠ #{message}", :yellow)
+    end
+
+    def error(message)
+      puts prompt.decorate("✗ #{message}", :red)
+    end
+
+    def info(message)
+      puts prompt.decorate("ℹ #{message}", :cyan)
+    end
+
+    def header(message)
+      puts
+      puts prompt.decorate("═" * 50, :blue)
+      puts prompt.decorate(" #{message}", :blue, :bold)
+      puts prompt.decorate("═" * 50, :blue)
+      puts
+    end
+
+    def review_reminder
+      puts
+      warning "IMPORTANT: Review the generated files carefully!"
+      puts "  AI-generated context is a first draft. The quality of your future"
+      puts "  AI interactions depends on the accuracy of these files."
+      puts
+      puts "  Suggested review steps:"
+      puts "    1. Read through each generated file"
+      puts "    2. Fix any inaccuracies or missing information"
+      puts "    3. Add project-specific details the AI might have missed"
+      puts "    4. Remove any incorrect assumptions"
+      puts
+    end
+
+    private
+
+    def format_size(bytes)
+      if bytes < 1024
+        "#{bytes} B"
+      elsif bytes < 1024 * 1024
+        "#{(bytes / 1024.0).round(1)} KB"
+      else
+        "#{(bytes / (1024.0 * 1024)).round(1)} MB"
+      end
+    end
+  end
+end

data/lib/ruby_ai_gem_context/platform.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RubyAiGemContext
+  # Base class for AI platform definitions
+  #
+  # Each platform (Claude, Cursor, Windsurf, etc.) defines:
+  # - The filename and location for context files
+  # - The template/format for the context file
+  # - The prompt to use when generating content
+  class Platform
+    class << self
+      # Human-readable name of the platform
+      def name
+        raise NotImplementedError
+      end
+
+      # The filename for the context file (e.g., "CLAUDE.md", ".cursorrules")
+      def filename
+        raise NotImplementedError
+      end
+
+      # Where the file should be placed relative to project root
+      # Most platforms expect files at the project root
+      def path
+        filename
+      end
+
+      # Description shown in the interactive menu
+      def description
+        raise NotImplementedError
+      end
+
+      # The prompt template for generating content
+      # This tells the AI what format and structure to use
+      def generation_prompt
+        raise NotImplementedError
+      end
+
+      # Template content for empty boilerplate
+      def template
+        raise NotImplementedError
+      end
+
+      # Check if the context file already exists
+      def exists?(project_root = Dir.pwd)
+        File.exist?(File.join(project_root, path))
+      end
+
+      # Full path to the context file
+      def full_path(project_root = Dir.pwd)
+        File.join(project_root, path)
+      end
+
+      # Write content to the context file
+      def write(content, project_root = Dir.pwd)
+        file_path = full_path(project_root)
+        FileUtils.mkdir_p(File.dirname(file_path))
+        File.write(file_path, content)
+        file_path
+      end
+
+      # Read existing content
+      def read(project_root = Dir.pwd)
+        return nil unless exists?(project_root)
+
+        File.read(full_path(project_root))
+      end
+
+      # Create backup of existing file
+      def backup(project_root = Dir.pwd)
+        return nil unless exists?(project_root)
+
+        backup_path = "#{full_path(project_root)}.backup"
+        FileUtils.cp(full_path(project_root), backup_path)
+        backup_path
+      end
+    end
+  end
+end

data/lib/ruby_ai_gem_context/platforms/claude.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module RubyAiGemContext
+  module Platforms
+    class Claude < Platform
+      class << self
+        def name
+          "Claude Code"
+        end
+
+        def filename
+          "CLAUDE.md"
+        end
+
+        def description
+          "Claude Code / Claude AI - Project context file"
+        end
+
+        def generation_prompt
+          <<~PROMPT
+            Generate a CLAUDE.md file for this Ruby project. This file helps Claude Code understand the project.
+
+            Structure the file with these sections:
+
+            # Project Name
+
+            Brief description of what this project does.
+
+            ## Quick Start
+
+            How to set up and run the project (install deps, run tests, start server, etc.)
+
+            ## Architecture
+
+            Key architectural decisions, folder structure, important patterns used.
+
+            ## Code Style
+
+            Coding conventions, naming patterns, formatting preferences for this project.
+
+            ## Common Tasks
+
+            Frequent development tasks and how to do them (run tests, lint, deploy, etc.)
+
+            ## Key Files
+
+            Important files to understand the codebase (entry points, config, core classes).
+
+            ## Gotchas
+
+            Non-obvious things, common mistakes, edge cases to watch out for.
+
+            Keep it concise and practical. Focus on information that helps an AI assistant understand and work with this codebase effectively.
+          PROMPT
+        end
+
+        def template
+          <<~TEMPLATE
+            # Project Name
+
+            Brief description of what this project does.
+
+            ## Quick Start
+
+            ```bash
+            # Install dependencies
+            bundle install
+
+            # Run tests
+            bundle exec rspec
+
+            # Start development
+            # Add commands here
+            ```
+
+            ## Architecture
+
+            Describe the key architectural decisions and patterns used in this project.
+
+            ## Code Style
+
+            - Ruby style conventions used
+            - Naming patterns
+            - File organization
+
+            ## Common Tasks
+
+            - **Run tests**: `bundle exec rspec`
+            - **Run linter**: `bundle exec rubocop`
+            - **Generate docs**: `bundle exec yard`
+
+            ## Key Files
+
+            - `lib/` - Main library code
+            - `spec/` - Test files
+            - `Gemfile` - Dependencies
+
+            ## Gotchas
+
+            - Things to watch out for
+            - Common mistakes
+            - Non-obvious behaviors
+          TEMPLATE
+        end
+      end
+    end
+  end
+end

data/lib/ruby_ai_gem_context/platforms/codex.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RubyAiGemContext
+  module Platforms
+    class Codex < Platform
+      class << self
+        def name
+          "OpenAI Codex / ChatGPT"
+        end
+
+        def filename
+          "AGENTS.md"
+        end
+
+        def description
+          "OpenAI Codex / ChatGPT - Agents documentation"
+        end
+
+        def generation_prompt
+          <<~PROMPT
+            Generate an AGENTS.md file for this Ruby project. This file helps AI coding assistants (like ChatGPT, Codex, GitHub Copilot) understand this project.
+
+            Structure the file with:
+
+            # Project Name
+
+            Brief description of what this project does and its purpose.
+
+            ## Setup
+
+            How to install and configure the project.
+
+            ## Usage
+
+            Common usage patterns with code examples.
+
+            ## Architecture
+
+            How the code is organized, key abstractions, design patterns.
+
+            ## API Reference
+
+            Key classes/modules and their public interfaces.
+
+            ## Development
+
+            How to contribute: running tests, code style, PR process.
+
+            ## Examples
+
+            Practical code examples showing common use cases.
+
+            Focus on clarity and include runnable code examples where helpful.
+          PROMPT
+        end
+
+        def template
+          <<~TEMPLATE
+            # Project Name
+
+            Brief description of what this project does.
+
+            ## Setup
+
+            ```bash
+            # Install
+            gem install project-name
+            # or add to Gemfile
+            gem 'project-name'
+            ```
+
+            ## Usage
+
+            ```ruby
+            require 'project_name'
+
+            # Basic usage example
+            ```
+
+            ## Architecture
+
+            Describe the overall architecture:
+            - Key modules and their responsibilities
+            - Design patterns used
+            - How components interact
+
+            ## API Reference
+
+            ### MainClass
+
+            ```ruby
+            # Constructor
+            MainClass.new(options)
+
+            # Key methods
+            instance.method_name(args)
+            ```
+
+            ## Development
+
+            ```bash
+            # Install dependencies
+            bundle install
+
+            # Run tests
+            bundle exec rspec
+
+            # Run linter
+            bundle exec rubocop
+            ```
+
+            ## Examples
+
+            ### Example 1: Basic Usage
+
+            ```ruby
+            # Show a complete working example
+            ```
+
+            ### Example 2: Advanced Usage
+
+            ```ruby
+            # Show more complex usage
+            ```
+          TEMPLATE
+        end
+      end
+    end
+  end
+end

data/lib/ruby_ai_gem_context/platforms/cursor.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RubyAiGemContext
+  module Platforms
+    class Cursor < Platform
+      class << self
+        def name
+          "Cursor"
+        end
+
+        def filename
+          ".cursorrules"
+        end
+
+        def description
+          "Cursor IDE - Project rules file"
+        end
+
+        def generation_prompt
+          <<~PROMPT
+            Generate a .cursorrules file for this Ruby project. This file tells Cursor AI how to work with this codebase.
+
+            The format should be clear instructions/rules, NOT markdown headers. Write it as a set of directives.
+
+            Include:
+
+            1. Project overview - What this project is and does
+            2. Tech stack - Ruby version, key gems, frameworks
+            3. Code style rules - Naming conventions, formatting, patterns to follow
+            4. File organization - Where different types of code live
+            5. Testing approach - How to write tests, what framework is used
+            6. Common patterns - Idioms and patterns used in this codebase
+            7. Things to avoid - Anti-patterns, deprecated approaches
+            8. Key commands - How to run tests, lint, build, etc.
+
+            Write in a direct, instructional tone. Each rule should be actionable.
+            Keep it focused on practical guidance for generating and modifying code.
+          PROMPT
+        end
+
+        def template
+          <<~TEMPLATE
+            # Project Overview
+            This is a Ruby project. Describe what it does here.
+
+            # Tech Stack
+            - Ruby 3.x
+            - RSpec for testing
+            - Add other key dependencies
+
+            # Code Style
+            - Use snake_case for methods and variables
+            - Use CamelCase for classes and modules
+            - Prefer single quotes for strings without interpolation
+            - Keep methods short and focused (under 10 lines ideally)
+            - Use meaningful variable names
+
+            # File Organization
+            - lib/ contains the main library code
+            - spec/ contains RSpec tests
+            - Each class gets its own file
+
+            # Testing
+            - Write RSpec tests for all new code
+            - Use describe/context/it blocks
+            - Prefer let over instance variables
+            - Test behavior, not implementation
+
+            # Patterns to Follow
+            - Dependency injection over global state
+            - Composition over inheritance
+            - Small, focused classes
+
+            # Things to Avoid
+            - Monkey patching core classes
+            - Global mutable state
+            - Deep inheritance hierarchies
+
+            # Commands
+            - Run tests: bundle exec rspec
+            - Run linter: bundle exec rubocop
+            - Install deps: bundle install
+          TEMPLATE
+        end
+      end
+    end
+  end
+end