# AI-Powered Code Generation Example

This example demonstrates advanced AI-powered code generation using ggen's AI capabilities:

- **Template Generation**: AI creates templates from natural language descriptions
- **Code Generation**: AI generates Rust code with proper error handling and testing
- **SPARQL Integration**: AI generates SPARQL queries from domain descriptions
- **Documentation**: AI generates comprehensive documentation
- **Validation**: AI validates generated code for quality and correctness

## Features Demonstrated

### AI Template Generation
- Natural language to template conversion
- Variable extraction and type inference
- Frontmatter generation with proper metadata
- Template validation and improvement

### AI Code Generation
- Rust service generation with multiple frameworks
- Database schema generation
- API endpoint generation
- Test case generation
- Error handling implementation

### AI SPARQL Generation
- Natural language to SPARQL query conversion
- Domain model analysis
- Query optimization suggestions
- Result interpretation

### AI Documentation Generation
- API documentation generation
- Architecture documentation
- User guides and tutorials
- Code comments and examples

## Quick Start

```bash
# Generate a complete Rust web service
ggen ai generate -d "Create a REST API for managing books with CRUD operations, authentication, and search functionality" --validate

# Generate SPARQL queries for domain analysis
ggen ai sparql -d "Find all entities and their relationships in the domain model" -g data/domain.ttl

# Generate documentation
ggen ai generate -d "Create comprehensive API documentation with examples and usage guides" --validate

# Generate test cases
ggen ai generate -d "Generate comprehensive test cases for the book management API" --validate
```

## Project Structure

```
ai-code-generation/
├── README.md                 # This file
├── ggen.toml                 # ggen configuration
├── make.toml                 # Lifecycle configuration
├── templates/                # AI-generated templates
│   ├── rust-service.tmpl     # Rust service template
│   ├── database-schema.tmpl  # Database schema template
│   ├── api-docs.tmpl         # API documentation template
│   └── tests.tmpl            # Test cases template
├── data/                     # Domain models and queries
│   ├── domain.ttl            # RDF domain model
│   ├── queries.sparql        # Generated SPARQL queries
│   └── examples.json         # Example data
├── generated/                # AI-generated code
│   ├── services/             # Generated services
│   ├── schemas/              # Generated schemas
│   ├── docs/                 # Generated documentation
│   └── tests/                # Generated tests
└── examples/                 # Usage examples
    ├── book-service/         # Book management service
    ├── user-service/         # User management service
    └── inventory-service/    # Inventory management service
```

## AI Generation Examples - Marketplace-First Approach

### 1. **Search Marketplace** for existing AI patterns
```bash
# Search for AI and web service packages
ggen market search "ai service"
ggen market search "rust web service"
ggen market search "crud templates"
ggen market search "database integration"
```

### 2. **Install Required Packages**
```bash
# Install AI and template packages
ggen market install "ai-service-templates"         # AI-powered service generation
ggen market install "rust-axum-service"             # Axum web framework
ggen market install "crud-operations"               # CRUD operation templates
ggen market install "postgresql-database"           # Database integration
ggen market install "redis-cache"                   # Caching layer
ggen market install "openapi-documentation"         # API documentation
```

### 3. **Service Generation** using marketplace templates + AI
```bash
# Generate book management service using marketplace template
ggen template generate ai-service-templates:book-service.tmpl

# Enhance with AI for custom requirements
ggen ai generate -d "
Enhance the generated book service with these additional features:
- Advanced search with multiple filters
- Book recommendations based on reading history
- Integration with external book APIs
- Real-time inventory tracking
- Automated restocking alerts
" --validate --max-iterations 3
```

### 2. SPARQL Query Generation
```bash
# Generate SPARQL queries for domain analysis
ggen ai sparql -d "
Analyze the book domain model and generate queries for:
- Finding all books by a specific author
- Listing books in a category with their details
- Finding books published in a date range
- Identifying books with low inventory
- Generating reports on book popularity
- Finding related books based on categories
" -g data/domain.ttl -o data/generated-queries.sparql
```

### 3. Documentation Generation
```bash
# Generate comprehensive documentation
ggen ai generate -d "
Create comprehensive documentation for the book management API including:
- API overview and architecture
- Endpoint documentation with examples
- Authentication and authorization
- Error handling and status codes
- Rate limiting and usage guidelines
- Integration examples
- Troubleshooting guide
- Performance optimization tips
" --validate
```

### 4. Test Generation
```bash
# Generate comprehensive test suite
ggen ai generate -d "
Generate a comprehensive test suite for the book management API including:
- Unit tests for all service methods
- Integration tests for API endpoints
- Database interaction tests
- Authentication and authorization tests
- Error handling tests
- Performance tests
- Load tests
- Mock data generation
" --validate
```

## Configuration

### ggen.toml
```toml
[ai]
provider = "ollama"
model = "qwen2.5-coder"
temperature = 0.7
max_tokens = 4000
timeout = 30

[ai.prompts]
system = "You are an expert Rust developer specializing in web services, databases, and API design. Generate production-ready code with proper error handling, testing, and documentation."
user_prefix = "Generate a Rust service with the following requirements:"

[ai.validation]
enabled = true
quality_threshold = 0.8
max_iterations = 3

[templates]
directory = "templates"
backup_enabled = true

[templates.rust]
style = "core-team"
error_handling = "thiserror"
logging = "tracing"
async_runtime = "tokio"
testing = "comprehensive"
```

## Advanced Features

### Iterative Improvement
The AI system can iteratively improve generated code based on validation feedback:

```bash
# Generate with iterative improvement
ggen ai generate -d "Create a user authentication service" --validate --max-iterations 5
```

### Quality Validation
Generated code is automatically validated for:
- Compilation correctness
- Test coverage
- Code quality metrics
- Security best practices
- Performance optimization

### Template Customization
Templates can be customized for specific frameworks and patterns:

```bash
# Generate with specific framework
ggen ai generate -d "Create a microservice" --template rust-service.tmpl --vars framework=axum
```

## Best Practices

### 1. Clear Descriptions
Provide clear, detailed descriptions for better AI generation:
- Specify exact requirements
- Include technical constraints
- Mention preferred frameworks and patterns
- Describe expected behavior

### 2. Iterative Refinement
Use iterative generation to improve quality:
- Start with basic requirements
- Add validation feedback
- Refine based on results
- Validate final output

### 3. Validation and Testing
Always validate generated code:
- Check compilation
- Run tests
- Verify functionality
- Review security implications

### 4. Documentation
Generate comprehensive documentation:
- API documentation
- Usage examples
- Architecture diagrams
- Troubleshooting guides

## Key Benefits of Marketplace-First AI Development

### **Intelligent Code Reuse** - Don't reinvent the wheel
- Marketplace provides proven, production-ready AI patterns
- AI enhances existing templates rather than generating from scratch
- Combines human expertise (marketplace) with AI adaptability

### **Quality Assurance** - Production-ready from day one
- Marketplace templates include proper error handling, security, logging
- AI enhancements maintain code quality standards
- Comprehensive validation ensures generated code works

### **Rapid Iteration** - Focus on business logic, not boilerplate
- 80% of code comes from marketplace templates
- AI handles the remaining 20% of custom requirements
- Faster development cycles with higher quality

### **Consistency** - Standardized patterns across projects
- All AI-generated services follow same architectural patterns
- Uniform error handling and API design
- Easier maintenance and team collaboration

## Best Practices for AI + Marketplace Development

### 1. **Start with Marketplace Search**
```bash
# Always search first - someone may have already solved your problem
ggen market search "your specific requirement"
ggen market categories  # See what's available
```

### 2. **Use Marketplace Templates as Foundation**
```bash
# Install proven patterns
ggen market install "your-required-package"

# Generate from marketplace template
ggen template generate package-name:template.tmpl

# Then enhance with AI for custom needs
ggen ai generate "Add my specific business requirements"
```

### 3. **Leverage AI for Complex Logic**
```bash
# Use AI for:
# - Complex business rules
# - Custom algorithms
# - Integration requirements
# - Performance optimizations

# Don't use AI for:
# - Basic CRUD operations (use marketplace)
# - Standard web frameworks (use marketplace)
# - Common patterns (use marketplace)
```

### 4. **Validate Everything**
```bash
# Always validate generated code
ggen lifecycle run test
ggen graph validate data/domain.ttl
ggen template validate templates/*.tmpl
```

### 5. **Contribute Back to Marketplace**
```bash
# After successful customization, consider publishing improvements
ggen market publish "my-enhanced-pattern"
```

This example demonstrates how to combine ggen's marketplace (human expertise) with AI generation (adaptability) for optimal development speed and quality.
