# OpenCrates: AI-Powered Rust Development Companion
OpenCrates is a comprehensive, AI-powered toolkit designed to accelerate Rust development by offering intelligent crate generation, project analysis, and advanced code assistance. It is built for professional developers who value efficiency, best practices, and robust tooling.
## Features
- **Intelligent Crate Generation**: Create new Rust crates from templates with AI-assisted configuration and dependency selection.
- **Advanced Project Analysis**: Perform comprehensive analysis of existing projects to identify dependencies, check for vulnerabilities, and suggest improvements.
- **AI-Powered Code Assistance**: Leverage OpenAI's GPT models for code completion, refactoring, and optimization suggestions.
- **Interactive TUI Dashboard**: Manage projects, view analysis results, and interact with AI features through a terminal-based user interface.
- **Extensible Agent System**: Utilize a flexible agent system for custom automated workflows and integrations.
- **Comprehensive Caching**: Speed up operations with a multi-layer caching system supporting both in-memory and Redis backends.
- **Web Server and API**: Expose OpenCrates' functionality through a FastAPI-based web server with a full REST API.
- **Metrics and Health Monitoring**: Monitor application performance and health with Prometheus-compatible metrics and health check endpoints.
## System Requirements
- Rust (1.70 or newer)
- Docker & Docker Compose (for containerized deployment)
- An active OpenAI API key
## Quick Start
### 1. Installation
Clone the repository and build the project:
```bash
git clone https://github.com/your-username/OpenCrates.git
cd OpenCrates
cargo build --release
```
### 2. Environment Configuration
Export your OpenAI API key as an environment variable:
```bash
export OPENAI_API_KEY="your-api-key"
```
### 3. Verify Installation
Run the test suite to ensure all components are functioning correctly:
```bash
cargo test
```
## Usage
OpenCrates provides a powerful command-line interface (CLI) for all its features.
### Initialize a Project
```bash
# Initialize a new project in the current directory
opencrates init
# Initialize in a specific directory
opencrates init ./my-new-project
```
### Generate a Crate
```bash
opencrates generate --name "my-awesome-crate" --description "A new crate generated by OpenCrates"
```
### Analyze a Project
```bash
# Analyze the current project and get AI recommendations
opencrates analyze --recommendations
```
### Start the Web Server
```bash
opencrates serve --host 127.0.0.1 --port 8080
```
Once running, the API is available at `http://127.0.0.1:8080`.
## Docker Deployment
For a containerized setup, use the provided Docker and Docker Compose configurations.
### Build the Docker Image
```bash
docker build -t opencrates-app .
```
### Run with Docker Compose
This will start the OpenCrates application server and a Redis instance for caching.
```bash
docker-compose up -d
```
## Development
### Running Tests
```bash
# Run all tests
cargo test
# Run only integration tests
cargo test --test integration_tests
```
### Code Formatting and Linting
This project uses `rustfmt` for formatting and `clippy` for linting.
```bash
cargo fmt
cargo clippy -- -D warnings
```
### Generating Documentation
```bash
cargo doc --open
```
This will build and open the project documentation in your web browser.
## Configuration
OpenCrates can be configured through various methods:
### Environment Variables
```bash
export OPENAI_API_KEY="your-api-key"
export OPENCRATES_HOST="0.0.0.0"
export OPENCRATES_PORT="8080"
export OPENCRATES_LOG_LEVEL="info"
```
### Configuration File
Create `opencrates.toml`:
```toml
[server]
host = "0.0.0.0"
port = 8080
workers = 4
[ai]
provider = "openai"
model = "gpt-4o"
max_tokens = 4096
temperature = 0.7
[database]
url = "sqlite:opencrates.db"
max_connections = 10
[cache]
type = "memory"
ttl = 3600
```
## API Reference
### FastAPI Endpoints
#### Health & Monitoring
- `GET /health` - System health check
- `GET /health/detailed` - Detailed health information
- `GET /metrics` - Prometheus metrics
- `GET /status` - System status
#### Core Operations
- `POST /api/generate` - Generate new crate
- `POST /api/search` - Search crates
- `GET /api/crates/{name}` - Get crate information
- `POST /api/analyze` - Analyze project
#### Configuration
- `GET /config` - Get application configuration
- `POST /config` - Update configuration
### WebSocket Events
- Real-time project updates
- Build status notifications
- AI agent communications
## Architecture
### System Components
```
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ CLI │ │ TUI │ │ FastAPI │
│ Interface │ │ Dashboard │ │ Server │
└─────────────────┘ └─────────────────┘ └─────────────────┘
│ │ │
└───────────────────────┼───────────────────────┘
│
┌─────────────────────────────────────────────────┐
│ Core Engine │
├─────────────────────────────────────────────────┤
│ • Project Analysis • Template Management │
│ • Code Generation • Metrics Collection │
│ • AI Integration • Health Monitoring │
└─────────────────────────────────────────────────┘
│
┌─────────────────────────────────────────────────┐
│ AI Agents Layer │
├─────────────────────────────────────────────────┤
│ • Crate Generator • Code Reviewer │
│ • Project Analyzer • Optimizer │
│ • Search Agent • Chat Assistant │
└─────────────────────────────────────────────────┘
│
┌─────────────────────────────────────────────────┐
│ External Services │
├─────────────────────────────────────────────────┤
│ • OpenAI API • Crates.io Registry │
│ • GitHub API • Docker Registry │
│ • Search Providers • Documentation APIs │
└─────────────────────────────────────────────────┘
```
### Data Flow
1. **Input Processing**: CLI/TUI/API receives user requests
2. **Context Analysis**: Core engine analyzes project context
3. **AI Processing**: Agents process requests with AI models
4. **Output Generation**: Results formatted and returned
5. **Monitoring**: Metrics and health data collected
## Testing
### Comprehensive Testing Suite
```bash
# Run all tests
./test_all.sh
# Individual test categories
cargo test --lib # Unit tests
cargo test --test integration_tests # Integration tests
cargo test --release bench # Benchmark tests
```
### Test Coverage
- **Unit Tests**: 95%+ coverage of core functionality
- **Integration Tests**: End-to-end workflow validation
- **Performance Tests**: Benchmark and load testing
- **Security Tests**: Vulnerability scanning and audit
### Continuous Integration
- Automated testing on push/PR
- Security vulnerability scanning
- Performance regression detection
- Documentation generation
## Performance
### Benchmarks
- **Code Generation**: < 2s for typical crates
- **Project Analysis**: < 5s for medium projects
- **API Response Time**: < 100ms for most endpoints
- **Memory Usage**: < 50MB baseline usage
- **Startup Time**: < 1s cold start
### Optimization Features
- Intelligent caching strategies
- Lazy loading of AI models
- Concurrent processing
- Memory-efficient data structures
- Optimized database queries
## Development
### Contributing
1. Fork the repository
2. Create a feature branch
3. Implement your changes
4. Add comprehensive tests
5. Submit a pull request
### Development Setup
```bash
# Clone and setup
git clone https://github.com/opencrates/opencrates.git
cd opencrates
# Install development dependencies
cargo install cargo-watch cargo-audit cargo-outdated
# Run in development mode
cargo run -- serve --dev
# Run with file watching
cargo watch -x "run -- serve --dev"
```
### Code Style
- Follow Rust standard formatting (`cargo fmt`)
- Pass all Clippy lints (`cargo clippy`)
- Maintain test coverage above 90%
- Document all public APIs
## Security
### Security Features
- API key encryption and secure storage
- Input validation and sanitization
- Rate limiting and DDoS protection
- Secure dependency management
- Regular security audits
### Vulnerability Management
- Automated dependency scanning
- Security advisory monitoring
- Regular penetration testing
- Responsible disclosure policy
## Roadmap
### Current Version (v0.1.1)
- ✅ Core CLI functionality
- ✅ AI integration with OpenAI
- ✅ Basic project analysis
- ✅ TUI dashboard
- ✅ FastAPI server
- ✅ Docker containerization
### Upcoming Features
- 🔄 Advanced code refactoring
- 🔄 Multi-language support
- 🔄 Plugin architecture
- 🔄 Cloud deployment options
- 🔄 Team collaboration features
### Future Vision
- 🚀 Visual Studio Code extension
- 🚀 GitHub Actions integration
- 🚀 Advanced ML models
- 🚀 Enterprise features
- 🚀 SaaS offering
## Support
### Documentation
- **API Documentation**: Available at `/docs` when server is running
- **User Guide**: Comprehensive usage examples
- **Developer Guide**: Architecture and contribution guidelines
### Community
- **GitHub Issues**: Bug reports and feature requests
- **Discussions**: Community Q&A and ideas
- **Discord**: Real-time community chat
### Professional Support
- **Enterprise Support**: Available for commercial users
- **Training**: Custom training and onboarding
- **Consulting**: Architecture and implementation guidance
## License
Licensed under either of:
- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE))
- MIT License ([LICENSE-MIT](LICENSE-MIT))
at your option.
## Acknowledgments
OpenCrates is built with and inspired by amazing open-source projects:
- **Rust Language**: For safety and performance
- **OpenAI**: For cutting-edge AI capabilities
- **Tokio**: For async runtime excellence
- **Axum**: For modern web framework design
- **Ratatui**: For beautiful terminal interfaces
---
**Made with ❤️ by the OpenCrates Team**
*Empowering Rust developers with AI-driven tools for the future of software development.*