🦆 Rubby Ducky

Your intelligent rubber duck debugging assistant powered by CodeBERT neural networks and comprehensive rule-based analysis.

✨ Features

• 🔍 Multi-Language Bug Detection: Supports Python, JavaScript, Java, C++, C#, Go, and Rust
• 🤖 AI-Powered Analysis: CodeBERT neural networks with 85-98% confidence for clean code
• 🛠️ Intelligent Classification: Smart logic combining rule-based + ML analysis
• 🌐 Modern Web Interface: Clean Streamlit interface with real-time analysis
• 📊 40+ Detection Rules: Comprehensive rule database across all languages
• ⚡ Fast CPU Analysis: No GPU required, optimized for speed and accuracy

🚀 Quick Start

1. Installation

# Clone the repository
git clone https://github.com/Daniel011503/Rubby-Ducky.git
cd Rubby-Ducky

# Create and activate virtual environment
python -m venv llama-env
# On Windows:
llama-env\Scripts\activate
# On Linux/Mac:
source llama-env/bin/activate

# Install dependencies
pip install -r requirements.txt

2. Usage Options

Option A: Web Interface (Recommended)

python -m streamlit run src/streamlit_app_clean.py

Then open http://localhost:8501 in your browser.

Option B: Command Line Analysis

# Analyze a specific file
python main.py analyze your_file.py --language python

# Examples for different languages
python main.py analyze code.js --language javascript
python main.py analyze App.java --language java
python main.py analyze main.cpp --language cpp

Option C: Direct Python Usage

from src.multi_language_processor import MultiLanguageCodeProcessor

# Initialize processor with ML models
processor = MultiLanguageCodeProcessor(language='python', use_ml_model=True)

# Analyze code
ml_result = processor.predict_bugs_ml(code)
syntax_errors = processor.detect_syntax_errors(code, 'python')
common_bugs = processor.detect_common_bugs(code, 'python')

🧠 How It Works

1. Intelligent Classification System

Rubby Ducky uses a sophisticated multi-layer approach:

• Rule-Based Analysis: 40+ patterns across 7 languages for immediate detection
• CodeBERT Neural Network: Microsoft's code-specialized BERT for semantic analysis
• Smart Classification Logic: Combines rule findings with ML confidence for accurate results

2. Analysis Categories

3. Language-Specific Rules

Each language has tailored detection patterns:

• Python: Indentation, f-strings, exception handling
• JavaScript: Semicolons, equality operators, async patterns
• Java: String concatenation, null safety, hashCode contracts
• C++: Memory management, null pointers, RAII
• C#: Properties, using statements, async patterns
• Go: Goroutines, error handling, capitalization
• Rust: Ownership, borrowing, safety patterns

📊 Current Performance

Accuracy Metrics

System Requirements

Performance Benchmarks

• Rule Analysis: ~50ms per file
• ML Analysis: ~200-500ms per file (CPU)
• Combined Analysis: ~300-600ms per file
• Model Loading: ~10-15s (first time only)

🎯 Example Results

Clean Code Example (Python)

def calculate_factorial(n: int) -> int:
    """Calculate factorial of a positive integer."""
    if n < 0:
        raise ValueError("Factorial not defined for negative numbers")
    if n <= 1:
        return 1
    return n * calculate_factorial(n - 1)

Result: 🤖 AI Analysis: Clean (confidence: 98.0%)

• ✅ No issues detected! Your code looks good.

Buggy Code Example (Python)

def buggy_function(x):
    if x = 5:  # Assignment instead of comparison
        print("x is five")
    return x + undefined_variable

Result: 🤖 AI Analysis: Buggy (confidence: 90.0%)

• 🚨 Line 2: Assignment (=) used instead of comparison (==)
• 🚨 Line 4: Undefined variable 'undefined_variable'

📁 Project Structure

Rubby-Ducky/
├── src/
│   ├── multi_language_processor.py  # Main analysis engine
│   ├── streamlit_app_clean.py       # Web interface
│   └── rule_engine.py               # Rule-based detection engine
├── data/
│   └── rules/                       # Language-specific rule databases
│       ├── python_rules.json
│       ├── javascript_rules.json
│       ├── java_rules.json
│       ├── cpp_rules.json
│       ├── csharp_rules.json
│       ├── go_rules.json
│       ├── rust_rules.json
│       └── common_rules.json
├── test_samples/
│   ├── clean/                       # Clean code examples
│   └── buggy/                       # Buggy code examples
├── main.py                          # CLI interface
├── requirements.txt                 # Dependencies
└── README.md                        # This file

🔧 Advanced Configuration

Model Configuration

# Use different confidence thresholds
processor = MultiLanguageCodeProcessor(
    language='python',
    use_ml_model=True,
    model_name='microsoft/codebert-base'  # Default
)

# Customize classification logic
processor.confidence_threshold = 0.7  # Adjust sensitivity

Rule Customization

Add custom rules to language-specific JSON files:

{
  "id": "custom_rule",
  "pattern": "your_regex_pattern",
  "message": "Your custom warning message",
  "severity": "medium",
  "category": "custom",
  "suggestion": "How to fix this issue"
}

🆚 Comparison with Modern AI

Current Status vs Leading Tools

Areas for Improvement

1. Model Upgrade: Current CodeBERT vs modern Code Llama 2/3
2. Context Window: Limited vs modern 8K-32K tokens
3. Fine-tuning: Generic CodeBERT vs specialized training
4. Multi-modal: Text-only vs code + documentation
5. Real-time: Batch analysis vs streaming responses

🚀 Roadmap for Model Improvement

Phase 1: Model Upgrade (Immediate)

• Integrate Code Llama 2 (7B/13B)
• Fine-tune on bug detection datasets
• Implement quantization for faster inference
• Add confidence calibration

Phase 2: Enhanced Features (3-6 months)

• Multi-file context analysis
• Code explanation generation
• Automated fix suggestions
• Integration with popular IDEs

Phase 3: Advanced AI (6-12 months)

• Custom training pipeline
• Retrieval-augmented generation (RAG)
• Multi-modal code understanding
• Conversational debugging interface

🤝 Contributing

We welcome contributions to improve Rubby Ducky's accuracy and capabilities!

Development Setup

# Install development dependencies
pip install -r requirements.txt
pip install pytest black flake8 mypy

# Run tests
pytest tests/

# Format code
black src/ main.py

# Lint code
flake8 src/ main.py

Adding New Languages

1. Create {language}_rules.json in data/rules/
2. Add language mapping in streamlit_app_clean.py
3. Update MultiLanguageCodeProcessor for language-specific logic
4. Add test cases and examples

Improving Detection Rules

1. Analyze false positives/negatives
2. Refine regex patterns in rule files
3. Test against diverse code samples
4. Submit PR with performance metrics

📜 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

• Microsoft for CodeBERT model
• Hugging Face for model infrastructure and transformers library
• Streamlit for the amazing web framework
• Open source community for inspiration and feedback

📞 Support

• 🐛 Bug Reports: GitHub Issues
• 💬 Discussions: GitHub Discussions
• 📧 Feature Requests: Create an issue with the "enhancement" label

---

⭐ Star this repository if Rubby Ducky helped debug your code! ⭐

"If you're going to talk to a duck about your code, why not make it a smart duck?" 🦆✨