code_healer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ea19c38b242524da0c2be758ff00108c1cbc277c976b818539487bb6279d33af
+  data.tar.gz: a93de9e58f4cae2a75f074515a3ffe3fc9973d64d05961e32b6ed34193090fd9
+SHA512:
+  metadata.gz: c7e457626092026ee1511022848c068a828fdab577e55ee3f2e3096c3b41191a7c97ad27b01c291a0485a3cd2d8d7e85e1649953efa4380e71800c2edde1f91e
+  data.tar.gz: e5edefe5097f704dee5969d86135a22ed19b35c1391c385fc2fd849559ca689a4390eba45b6f6a084861cd5395c525b22d47ef365de2443f701bfe0a4cbb7608

data/CHANGELOG.md

@@ -0,0 +1,70 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+- Initial gem release
+- AI-powered error analysis and code generation
+- Multiple healing strategies (API, Claude Code, Hybrid)
+- Business context awareness and integration
+- Automated Git operations and PR creation
+- Background job processing with Sidekiq
+- Comprehensive YAML configuration
+- Business requirements integration from markdown files
+- Rails integration via Railtie
+
+### Changed
+- Converted from standalone Rails application to gem
+- Refactored for modular architecture
+- Improved error handling and logging
+- Renamed from CodeHealer to CodeHealer
+
+### Deprecated
+- None
+
+### Removed
+- None
+
+### Fixed
+- Business context loading from markdown files
+- Template placeholder substitution in PR creation
+- Sidekiq job serialization issues
+
+### Security
+- Class restriction system for security
+- Environment variable support for sensitive data
+- Business rule validation
+
+## [0.1.0] - 2025-01-13
+
+### Added
+- Initial release of CodeHealer gem
+- Core healing engine
+- OpenAI API integration
+- Claude Code terminal integration
+- Business context management
+- Git operations automation
+- Sidekiq background processing
+- Comprehensive documentation
+- Example configurations
+- Test suite setup
+
+---
+
+## Version History
+
+- **0.1.0**: Initial gem release with core functionality
+- **Unreleased**: Future improvements and features
+
+## Contributing
+
+Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on our code of conduct and the process for submitting pull requests.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE.txt) file for details.

data/GEM_SUMMARY.md

@@ -0,0 +1,307 @@
+# CodeHealer Gem - Complete Package 🏥
+
+## 📦 What You Get
+
+This gem package contains everything needed to integrate AI-powered code healing and self-repair into any Ruby application.
+
+## 🏗️ Gem Structure
+
+```
+code_healer_gem/
+├── lib/
+│   ├── code_healer.rb                # Main gem file with Railtie
+│   ├── code_healer/
+│   │   ├── version.rb                # Gem version
+│   │   ├── config_manager.rb         # Configuration management
+│   │   ├── core.rb                   # Core healing engine
+│   │   ├── simple_healer.rb          # Basic healing logic
+│   │   ├── claude_code_healing_handler.rb  # Claude Code integration
+│   │   ├── business_context_manager.rb      # Business rules management
+│   │   ├── mcp_server.rb             # MCP server for AI integration
+│   │   ├── mcp_tools.rb              # MCP tools and utilities
+│   │   ├── mcp_prompts.rb            # AI prompt templates
+│   │   ├── pull_request_creator.rb   # Git operations automation
+│   │   ├── error_handler.rb          # Error handling utilities
+│   │   ├── usage_analyzer.rb         # Usage analytics
+│   │   └── healing_job.rb            # Sidekiq background job
+├── config/
+│   └── code_healer.yml.example       # Example configuration
+├── examples/
+│   └── basic_usage.rb                # Basic usage example
+├── docs/
+│   └── INSTALLATION.md               # Detailed installation guide
+├── spec/                             # Test suite
+├── code_healer.gemspec               # Gem specification
+├── Gemfile                           # Development dependencies
+├── Rakefile                          # Build and development tasks
+├── README.md                         # Comprehensive documentation
+├── CHANGELOG.md                      # Version history
+└── LICENSE.txt                       # MIT license
+```
+
+## 🚀 Quick Start for Users
+
+### 1. Add to Gemfile
+```ruby
+gem 'self_evolving'
+```
+
+### 2. Install
+```bash
+bundle install
+```
+
+### 3. Configure
+```bash
+cp config/self_evolution.yml.example config/self_evolution.yml
+# Edit the configuration file
+```
+
+### 4. Use
+```ruby
+# Your models will automatically evolve when errors occur
+class User < ApplicationRecord
+  def calculate_discount(amount, percentage)
+    amount * (percentage / 100.0)  # Will auto-fix if error occurs
+  end
+end
+```
+
+## 🔧 Key Features
+
+### 🤖 **Multiple AI Integration Options**
+- **OpenAI API**: Cloud-based, production-ready
+- **Claude Code Terminal**: Local, offline, full codebase access
+- **Hybrid**: Best of both worlds with fallback
+
+### 🎯 **Business Context Awareness**
+- YAML configuration for business rules
+- Markdown file integration for requirements
+- Domain-specific validation patterns
+
+### 🔄 **Automated Evolution**
+- Error detection and analysis
+- AI-powered fix generation
+- Automatic code application
+- Class reloading for immediate testing
+
+### 📝 **Git Operations Automation**
+- Feature branch creation
+- Automatic commits with descriptive messages
+- Pull request creation
+- Configurable target branches
+
+### ⚡ **Background Processing**
+- Sidekiq integration for non-blocking evolution
+- Queue management and retry logic
+- Evolution job monitoring
+
+## 📋 Configuration Options
+
+### Core Settings
+```yaml
+enabled: true
+allowed_classes: [User, Order, PaymentProcessor]
+excluded_classes: [ApplicationController, ApplicationRecord]
+allowed_error_types: [ArgumentError, TypeError, NoMethodError]
+```
+
+### Evolution Strategy
+```yaml
+evolution_strategy:
+  method: "api"  # or "claude_code_terminal" or "hybrid"
+  fallback_to_api: true
+```
+
+### Business Context
+```yaml
+business_context:
+  enabled: true
+  User:
+    domain: "User Management"
+    key_rules:
+      - "Email must be unique and valid"
+    validation_patterns:
+      - "Input validation for all parameters"
+```
+
+### Git Operations
+```yaml
+git:
+  auto_commit: true
+  auto_push: true
+  branch_prefix: evolve
+  pr_target_branch: main
+
+pull_request:
+  enabled: true
+  auto_create: true
+  labels: ["auto-fix", "self-evolving"]
+```
+
+## 🎨 Customization
+
+### Custom Error Handlers
+```ruby
+# config/initializers/self_evolution.rb
+Rails.application.config.after_initialize do
+  CodeHealer::Core.configure do |config|
+    config.custom_error_handler = ->(error, context) {
+      # Custom error handling logic
+    }
+  end
+end
+```
+
+### Custom Evolution Jobs
+```ruby
+# app/jobs/custom_evolution_job.rb
+class CustomEvolutionJob < CodeHealer::EvolutionJob
+  sidekiq_options queue: 'high_priority_evolution'
+  
+  def perform(error_data, class_name, method_name, file_path)
+    # Custom evolution logic
+    super
+  end
+end
+```
+
+### Business Context Sources
+```yaml
+claude_code:
+  business_context_sources:
+    - "config/business_rules.yml"
+    - "docs/business_logic.md"
+    - "spec/business_context_specs.rb"
+    - "app/models/concerns/business_rules.rb"
+```
+
+## 🧪 Testing
+
+### Run Tests
+```bash
+bundle exec rspec
+```
+
+### Test Configuration
+```yaml
+# config/self_evolution.yml (test environment)
+test:
+  enabled: false
+  mock_ai_responses: true
+  dry_run: true
+```
+
+### Mock Responses
+```yaml
+test:
+  mock_response: |
+    def calculate_discount(amount, percentage)
+      return 0 if amount.nil? || percentage.nil?
+      amount * (percentage / 100.0)
+    end
+```
+
+## 📊 Monitoring
+
+### Log Levels
+- `INFO`: General evolution activities
+- `WARN`: Potential issues or fallbacks
+- `ERROR`: Evolution failures
+- `DEBUG`: Detailed debugging information
+
+### Metrics
+```ruby
+# Access evolution metrics
+CodeHealer::UsageAnalyzer.get_evolution_stats
+CodeHealer::UsageAnalyzer.get_business_rule_compliance
+```
+
+### Sidekiq Web UI
+```ruby
+# config/routes.rb
+mount Sidekiq::Web => '/sidekiq'
+```
+
+## 🔒 Security
+
+### API Keys
+```yaml
+api:
+  provider: "openai"
+  api_key: <%= ENV['OPENAI_API_KEY'] %>
+```
+
+### Class Restrictions
+```yaml
+allowed_classes:
+  - User
+  - Order
+  # Never include ApplicationController, ApplicationRecord, etc.
+```
+
+### Business Rule Validation
+```yaml
+business_context:
+  validate_rules: true
+  strict_mode: true
+```
+
+## 🚨 Troubleshooting
+
+### Common Issues
+1. **Evolution not triggering**: Check class permissions and error types
+2. **AI integration failing**: Verify API keys and network connectivity
+3. **Git operations failing**: Check repository configuration and tokens
+4. **Business context not loading**: Verify file paths and permissions
+
+### Debug Mode
+```yaml
+logging:
+  level: debug
+  show_thinking_process: true
+  verbose: true
+```
+
+## 📚 Documentation
+
+- **README.md**: Comprehensive usage guide
+- **docs/INSTALLATION.md**: Step-by-step installation
+- **examples/basic_usage.rb**: Basic usage examples
+- **CHANGELOG.md**: Version history and changes
+
+## 🤝 Support
+
+- 📧 **Email**: deepan@example.com
+- 🐛 **Issues**: GitHub Issues
+- 💬 **Discussions**: GitHub Discussions
+- 📖 **Wiki**: GitHub Wiki
+
+## 🎯 Use Cases
+
+### Development
+- Automatic bug fixes during development
+- Code improvement suggestions
+- Business rule enforcement
+
+### Production
+- Runtime error recovery
+- Performance optimization
+- Security vulnerability fixes
+
+### Testing
+- Test case generation
+- Edge case handling
+- Validation improvement
+
+## 🚀 Getting Started
+
+1. **Read the README.md** for comprehensive information
+2. **Follow INSTALLATION.md** for setup steps
+3. **Run examples/basic_usage.rb** to see it in action
+4. **Customize config/self_evolution.yml** for your needs
+5. **Start evolving your code!**
+
+---
+
+**Transform your Rails application into a self-improving, intelligent system today! 🚀**

data/README.md

@@ -0,0 +1,281 @@
+# CodeHealer 🏥
+
+**AI-Powered Code Healing and Self-Repair System for Ruby Applications**
+
+[![Gem Version](https://badge.fury.io/rb/code_healer.svg)](https://badge.fury.io/rb/code_healer)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+CodeHealer automatically detects runtime errors in your Ruby/Rails application and uses AI to generate intelligent, context-aware fixes. It's like having a senior developer on call 24/7 to fix your bugs!
+
+## ✨ Features
+
+- **🚨 Automatic Error Detection** - Catches runtime errors in real-time
+- **🤖 AI-Powered Fix Generation** - Uses OpenAI GPT models for intelligent code fixes
+- **💼 Business Context Awareness** - Incorporates your business rules and domain knowledge
+- **🔄 Automatic Code Patching** - Applies fixes directly to your source code
+- **📝 Git Integration** - Creates commits and pull requests for all fixes
+- **⚡ Background Processing** - Uses Sidekiq for non-blocking error resolution
+- **🔧 Multiple Healing Strategies** - API-based, Claude Code Terminal, or hybrid approaches
+
+## Dependencies
+
+CodeHealer requires the following gems:
+
+- **Rails** (>= 6.0.0) - Web framework integration
+- **Sidekiq** (>= 6.0.0) - Background job processing
+- **Redis** (>= 4.0.0) - Sidekiq backend
+- **Octokit** (>= 4.0.0) - GitHub API integration
+- **Git** (>= 1.0.0) - Git operations
+- **OpenAI** (>= 0.16.0) - AI-powered code generation
+
+## Installation
+
+### 1. Interactive Installation (Recommended)
+
+The easiest way to get started is using our interactive setup script:
+
+```bash
+# Install the gem
+gem install code_healer
+
+# Run the interactive setup in your Rails app directory
+code_healer-setup
+```
+
+The setup script will:
+- ✅ Add CodeHealer to your Gemfile
+- 🔑 Collect your OpenAI API key and GitHub token
+- 📝 Create configuration files
+- 💼 Set up business context
+- 📦 Install dependencies
+
+### 2. Manual Installation
+
+```bash
+# Add to your Gemfile
+gem 'code_healer'
+
+# Install dependencies
+bundle install
+```
+
+### 3. Environment Variables
+
+CodeHealer requires several environment variables to function properly:
+
+```bash
+# Required for AI-powered code generation
+OPENAI_API_KEY=your_openai_api_key_here
+
+# Required for GitHub integration (PR creation, etc.)
+GITHUB_TOKEN=your_github_personal_access_token
+GITHUB_REPOSITORY=username/repository_name
+
+# Optional: Redis URL for Sidekiq
+REDIS_URL=redis://localhost:6379/0
+```
+
+**Loading Environment Variables:**
+
+You have several options for loading these variables:
+
+1. **Using dotenv-rails (Recommended):**
+   ```ruby
+   # In your Gemfile
+   gem 'dotenv-rails'
+   ```
+
+2. **Manual export in shell:**
+   ```bash
+   export OPENAI_API_KEY=your_key
+   export GITHUB_TOKEN=your_token
+   export GITHUB_REPOSITORY=username/repo
+   ```
+
+3. **Load directly in application.rb:**
+   ```ruby
+   # In config/application.rb
+   load '.env' if File.exist?('.env')
+   ```
+
+## ⚙️ Configuration
+
+### Environment Variables
+
+Create a `.env` file in your Rails app root:
+
+```bash
+# OpenAI Configuration
+OPENAI_API_KEY=your_openai_api_key_here
+
+# GitHub Configuration  
+GITHUB_TOKEN=your_github_token_here
+GITHUB_REPOSITORY=username/repo
+
+# Optional: Redis Configuration
+REDIS_URL=redis://localhost:6379/0
+```
+
+### Configuration File
+
+The setup script creates `config/code_healer.yml` automatically, or you can create it manually:
+
+```yaml
+enabled: true
+
+# Allowed classes for healing
+allowed_classes:
+  - User
+  - Order
+  - PaymentProcessor
+
+# Evolution strategy
+evolution_strategy:
+  method: api  # Options: api, claude_code_terminal, hybrid
+  fallback_to_api: true
+
+# OpenAI API configuration
+api:
+  provider: openai
+  model: gpt-4
+  max_tokens: 2000
+  temperature: 0.1
+
+# Git operations
+git:
+  auto_commit: true
+  auto_push: true
+  branch_prefix: "heal"
+```
+
+## 🏥 How It Works
+
+1. **Error Detection**: CodeHealer catches runtime errors using Rails error reporting
+2. **Context Analysis**: Analyzes the error with business context and codebase information
+3. **AI Fix Generation**: Uses OpenAI to generate intelligent, context-aware fixes
+4. **Code Patching**: Automatically applies fixes to your source files
+5. **Git Operations**: Creates commits and optionally pushes changes
+6. **Class Reloading**: Reloads patched classes to apply fixes immediately
+
+## 📖 Usage Examples
+
+### Basic Usage
+
+Once configured, CodeHealer works automatically! Just run your Rails app:
+
+```bash
+# Start your Rails server
+rails s
+
+# Start Sidekiq for background processing
+bundle exec sidekiq
+```
+
+### Testing the Healing
+
+Create a model with intentional errors to test:
+
+```ruby
+# app/models/broken_calculator.rb
+class BrokenCalculator < ApplicationRecord
+  def divide(a, b)
+    a / b  # This will cause ZeroDivisionError when b = 0
+  end
+end
+```
+
+When you hit an endpoint that triggers this error, CodeHealer will:
+1. Catch the error automatically
+2. Generate a fix using AI
+3. Apply the fix to your code
+4. Create a Git commit
+5. Reload the class
+
+### Viewing Healing Results
+
+Check your Sidekiq dashboard at `http://localhost:3000/sidekiq` to see healing jobs in action.
+
+## 🔧 Advanced Configuration
+
+### Business Context
+
+Create `docs/business_rules.md` to provide domain-specific context:
+
+```markdown
+# Business Rules
+
+## Error Handling
+- All errors should be logged for audit purposes
+- User-facing errors should be user-friendly
+- Critical errors should trigger alerts
+
+## Data Validation
+- All user inputs must be validated
+- Business rules must be enforced
+- Invalid data should be rejected with clear messages
+```
+
+### Custom Healing Strategies
+
+```yaml
+# Use Claude Code Terminal for local development
+evolution_strategy:
+  method: claude_code_terminal
+  fallback_to_api: true
+
+claude_code:
+  enabled: true
+  command_template: "claude --print '{prompt}' --output-format text"
+```
+
+## 🛠️ Development
+
+### Building the Gem
+
+```bash
+git clone https://github.com/deepan-g2/code-healer.git
+cd code-healer
+bundle install
+gem build code_healer.gemspec
+```
+
+### Running Tests
+
+```bash
+bundle exec rspec
+```
+
+## 📚 Documentation
+
+- [Installation Guide](docs/INSTALLATION.md)
+- [Configuration Reference](docs/CONFIGURATION.md)
+- [API Documentation](docs/API.md)
+- [Examples](examples/)
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE.txt](LICENSE.txt) file for details.
+
+## 🙏 Acknowledgments
+
+- Built with ❤️ by the CodeHealer Team
+- Powered by OpenAI's GPT models
+- Inspired by the need for self-healing applications
+
+## 📞 Support
+
+- 📧 Email: support@code-healer.com
+- 🐛 Issues: [GitHub Issues](https://github.com/deepan-g2/code-healer/issues)
+- 📖 Documentation: [docs.code-healer.com](https://docs.code-healer.com)
+
+---
+
+**CodeHealer** - Because your code deserves to heal itself! 🏥✨