@smicolon/ai-kit 0.3.2 → 0.4.0

package/packs/django/commands/test-generate.md

@@ -1,325 +0,0 @@
----
-name: test-generate
-description: Generate comprehensive tests for Django code (90%+ coverage target)
----
-
-# Django Test Generation
-
-You are a Django testing specialist. Your task is to generate comprehensive tests that achieve 90%+ code coverage following Smicolon standards.
-
-## Core Requirements
-
-### Import Pattern (CRITICAL)
-```python
-# ✅ CORRECT
-import users.models as _users_models
-import users.services as _users_services
-import users.serializers as _users_serializers
-from django.test import TestCase
-from rest_framework.test import APITestCase, APIClient
-```
-
-### Test Categories
-
-1. **Model Tests** - Test model methods, constraints, relationships
-2. **Service Tests** - Test business logic, transactions
-3. **API Tests** - Test endpoints, permissions, validation
-4. **Integration Tests** - Test complete workflows
-
-## Test Structure
-
-### Model Tests
-```python
-# app/tests/test_models.py
-import users.models as _users_models
-from django.test import TestCase
-from django.db import IntegrityError
-
-class ProductModelTest(TestCase):
-    def setUp(self):
-        self.product = _models.Product.objects.create(
-            name='Test Product',
-            slug='test-product',
-            description='Test description',
-            price=99.99,
-            stock=10
-        )
-
-    def test_product_creation(self):
-        """Test product is created with required fields"""
-        self.assertIsNotNone(self.product.id)
-        self.assertIsNotNone(self.product.created_at)
-        self.assertFalse(self.product.is_deleted)
-
-    def test_product_str(self):
-        """Test string representation"""
-        self.assertEqual(str(self.product), 'Test Product')
-
-    def test_slug_unique_constraint(self):
-        """Test slug must be unique"""
-        with self.assertRaises(IntegrityError):
-            _models.Product.objects.create(
-                name='Another Product',
-                slug='test-product',  # Duplicate slug
-                price=49.99
-            )
-
-    def test_price_non_negative(self):
-        """Test price cannot be negative"""
-        with self.assertRaises(IntegrityError):
-            _models.Product.objects.create(
-                name='Invalid Product',
-                slug='invalid',
-                price=-10.00
-            )
-
-    def test_soft_delete(self):
-        """Test soft delete functionality"""
-        product_id = self.product.id
-        self.product.is_deleted = True
-        self.product.save()
-
-        # Product still exists in database
-        product = _models.Product.objects.get(id=product_id)
-        self.assertTrue(product.is_deleted)
-```
-
-### Service Tests
-```python
-# app/tests/test_services.py
-import users.models as _users_models
-import users.services as _users_services
-from django.test import TestCase, TransactionTestCase
-from django.db import transaction
-
-class ProductServiceTest(TransactionTestCase):
-    def setUp(self):
-        self.user = # Create test user
-
-    def test_create_product(self):
-        """Test product creation through service"""
-        data = {
-            'name': 'New Product',
-            'slug': 'new-product',
-            'description': 'New description',
-            'price': 149.99,
-            'stock': 5
-        }
-
-        product = _services.ProductService.create_product(data, self.user)
-
-        self.assertIsNotNone(product.id)
-        self.assertEqual(product.name, 'New Product')
-        self.assertEqual(product.created_by, self.user)
-
-    def test_update_product(self):
-        """Test product update through service"""
-        product = _models.Product.objects.create(
-            name='Original',
-            slug='original',
-            price=100.00
-        )
-
-        data = {'name': 'Updated'}
-        updated = _services.ProductService.update_product(str(product.id), data)
-
-        self.assertEqual(updated.name, 'Updated')
-        self.assertEqual(updated.slug, 'original')  # Unchanged
-
-    def test_delete_product(self):
-        """Test soft delete through service"""
-        product = _models.Product.objects.create(
-            name='To Delete',
-            slug='to-delete',
-            price=50.00
-        )
-
-        _services.ProductService.delete_product(str(product.id))
-
-        product.refresh_from_db()
-        self.assertTrue(product.is_deleted)
-
-    def test_transaction_rollback(self):
-        """Test transaction rollback on error"""
-        with self.assertRaises(Exception):
-            with transaction.atomic():
-                product = _models.Product.objects.create(
-                    name='Test',
-                    slug='test',
-                    price=100.00
-                )
-                raise Exception("Simulated error")
-
-        # Product should not exist due to rollback
-        self.assertEqual(_models.Product.objects.count(), 0)
-```
-
-### API Tests
-```python
-# app/tests/test_api.py
-import users.models as _users_models
-from rest_framework.test import APITestCase
-from rest_framework import status
-
-class ProductAPITest(APITestCase):
-    def setUp(self):
-        self.user = # Create test user
-        self.client.force_authenticate(user=self.user)
-
-        self.product = _models.Product.objects.create(
-            name='Test Product',
-            slug='test-product',
-            price=99.99
-        )
-
-    def test_list_products(self):
-        """Test listing products"""
-        response = self.client.get('/api/products/')
-
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.assertEqual(len(response.data), 1)
-
-    def test_create_product(self):
-        """Test creating product via API"""
-        data = {
-            'name': 'New Product',
-            'slug': 'new-product',
-            'description': 'Description',
-            'price': '149.99',
-            'stock': 10
-        }
-
-        response = self.client.post('/api/products/', data)
-
-        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
-        self.assertEqual(_models.Product.objects.count(), 2)
-
-    def test_create_product_validation_error(self):
-        """Test validation errors"""
-        data = {
-            'name': 'Invalid',
-            'slug': 'invalid',
-            'price': '-10.00'  # Negative price
-        }
-
-        response = self.client.post('/api/products/', data)
-
-        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
-        self.assertIn('price', response.data)
-
-    def test_update_product(self):
-        """Test updating product"""
-        data = {'name': 'Updated Name'}
-
-        response = self.client.patch(
-            f'/api/products/{self.product.id}/',
-            data
-        )
-
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.product.refresh_from_db()
-        self.assertEqual(self.product.name, 'Updated Name')
-
-    def test_delete_product(self):
-        """Test deleting product"""
-        response = self.client.delete(f'/api/products/{self.product.id}/')
-
-        self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
-        self.product.refresh_from_db()
-        self.assertTrue(self.product.is_deleted)
-
-    def test_permissions_unauthenticated(self):
-        """Test unauthenticated access is denied"""
-        self.client.force_authenticate(user=None)
-
-        response = self.client.get('/api/products/')
-
-        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
-
-    def test_query_optimization(self):
-        """Test queryset is optimized"""
-        with self.assertNumQueries(2):  # Should use select_related
-            response = self.client.get('/api/products/')
-            list(response.data)  # Force evaluation
-```
-
-### Integration Tests
-```python
-# app/tests/test_integration.py
-import users.models as _users_models
-from rest_framework.test import APITestCase
-
-class ProductWorkflowTest(APITestCase):
-    def test_complete_product_lifecycle(self):
-        """Test complete product creation to deletion workflow"""
-        user = # Create test user
-        self.client.force_authenticate(user=user)
-
-        # 1. Create product
-        create_data = {
-            'name': 'Workflow Product',
-            'slug': 'workflow-product',
-            'price': '99.99',
-            'stock': 10
-        }
-        create_response = self.client.post('/api/products/', create_data)
-        product_id = create_response.data['id']
-
-        # 2. Retrieve product
-        get_response = self.client.get(f'/api/products/{product_id}/')
-        self.assertEqual(get_response.data['name'], 'Workflow Product')
-
-        # 3. Update product
-        update_data = {'stock': 20}
-        self.client.patch(f'/api/products/{product_id}/', update_data)
-
-        # 4. Custom action
-        restock_data = {'quantity': 5}
-        self.client.post(f'/api/products/{product_id}/restock/', restock_data)
-
-        # 5. Verify final state
-        final_response = self.client.get(f'/api/products/{product_id}/')
-        self.assertEqual(final_response.data['stock'], 25)
-
-        # 6. Delete product
-        self.client.delete(f'/api/products/{product_id}/')
-
-        # 7. Verify soft delete
-        product = _models.Product.objects.get(id=product_id)
-        self.assertTrue(product.is_deleted)
-```
-
-## Running Tests
-
-```bash
-# Run all tests
-python manage.py test
-
-# Run specific test file
-python manage.py test app.tests.test_models
-
-# Run specific test class
-python manage.py test app.tests.test_models.ProductModelTest
-
-# Run with coverage
-coverage run --source='.' manage.py test
-coverage report
-coverage html
-```
-
-## Quality Checklist
-
-- [ ] Model tests (creation, constraints, methods)
-- [ ] Service tests (business logic, transactions)
-- [ ] API tests (CRUD operations)
-- [ ] Permission tests
-- [ ] Validation tests
-- [ ] Error handling tests
-- [ ] Integration tests
-- [ ] Edge cases covered
-- [ ] Query optimization tests
-- [ ] 90%+ code coverage
-- [ ] Absolute imports with aliases
-- [ ] Clear test names and docstrings
-
-Now, ask the user what code they want to test!

package/packs/django/rules/migrations.md

@@ -1,138 +0,0 @@
----
-paths:
-  - "**/migrations/**/*.py"
----
-
-# Django Migration Standards
-
-## Safety First
-
-Migrations MUST be:
-- Reversible
-- Non-destructive
-- Tested before deployment
-
-## Dangerous Operations
-
-### Column Removal (3-step process)
-
-```python
-# Step 1: Make nullable (Migration 1)
-migrations.AlterField(
-    model_name='user',
-    name='legacy_field',
-    field=models.CharField(max_length=100, null=True, blank=True),
-)
-
-# Step 2: Deploy code that stops writing to field
-# Step 3: Remove field (Migration 2, separate deploy)
-migrations.RemoveField(
-    model_name='user',
-    name='legacy_field',
-)
-```
-
-### Type Changes
-
-```python
-# WRONG - Data loss risk
-migrations.AlterField(
-    model_name='product',
-    name='price',
-    field=models.IntegerField(),  # Was DecimalField!
-)
-
-# CORRECT - Add new field, migrate data, remove old
-migrations.AddField(
-    model_name='product',
-    name='price_cents',
-    field=models.IntegerField(null=True),
-)
-migrations.RunPython(migrate_price_to_cents, reverse_migrate),
-migrations.RemoveField('product', 'price'),
-migrations.RenameField('product', 'price_cents', 'price'),
-```
-
-## Requirements
-
-- Always include `reverse_code` for RunPython
-- Test migrations: forward AND backward
-- Never use `--fake` in production
-- Review auto-generated migrations before committing
-
-## RunPython Template
-
-```python
-def migrate_forward(apps, schema_editor):
-    """
-    Migration: Convert price to cents.
-    """
-    Product = apps.get_model('products', 'Product')
-    for product in Product.objects.all():
-        product.price_cents = int(product.price * 100)
-        product.save(update_fields=['price_cents'])
-
-
-def migrate_backward(apps, schema_editor):
-    """
-    Reverse: Convert cents back to price.
-    """
-    Product = apps.get_model('products', 'Product')
-    for product in Product.objects.all():
-        product.price = product.price_cents / 100
-        product.save(update_fields=['price'])
-
-
-class Migration(migrations.Migration):
-    operations = [
-        migrations.RunPython(migrate_forward, migrate_backward),
-    ]
-```
-
-## Forbidden Patterns
-
-- `RunPython(migrate_forward, migrations.RunPython.noop)` - Always provide reverse
-- `migrations.DeleteModel` without data backup plan
-- Large data migrations without batching
-- Migrations that lock tables for long periods
-
-## Large Table Migrations
-
-For tables with >1M rows:
-
-```python
-def migrate_in_batches(apps, schema_editor):
-    """Migrate data in batches to avoid lock timeouts."""
-    Product = apps.get_model('products', 'Product')
-    batch_size = 1000
-    total = Product.objects.count()
-
-    for start in range(0, total, batch_size):
-        batch = Product.objects.all()[start:start + batch_size]
-        for product in batch:
-            product.new_field = transform(product.old_field)
-        Product.objects.bulk_update(batch, ['new_field'])
-```
-
-## Migration Naming
-
-Use descriptive names:
-
-```bash
-# GOOD
-python manage.py makemigrations --name add_email_verified_field
-python manage.py makemigrations --name remove_legacy_status_column
-
-# BAD (auto-generated)
-0023_auto_20241201_1234.py
-```
-
-## Pre-Deployment Checklist
-
-- [ ] Migration is reversible
-- [ ] Tested forward migration locally
-- [ ] Tested backward migration locally
-- [ ] No destructive operations without 3-step process
-- [ ] Large tables use batching
-- [ ] RunPython has reverse_code
-- [ ] Migration name is descriptive

package/packs/django/rules/models.md

@@ -1,167 +0,0 @@
----
-paths:
-  - "**/models.py"
-  - "**/models/*.py"
----
-
-# Django Model Standards
-
-## BaseModel Pattern (MANDATORY)
-
-All models MUST inherit from `BaseModel`. Never repeat UUID/timestamp fields.
-
-### Step 1: Ensure BaseModel Exists
-
-Check for BaseModel in your project (usually in `core/models.py` or `shared/models.py`):
-
-```python
-# core/models.py
-import uuid
-from django.db import models
-
-class BaseModel(models.Model):
-    """
-    Abstract base model providing:
-    - UUID primary key
-    - Automatic timestamps (created_at, updated_at)
-    - Soft delete support (is_deleted)
-
-    All models MUST inherit from this class.
-    """
-
-    id = models.UUIDField(
-        primary_key=True,
-        default=uuid.uuid4,
-        editable=False
-    )
-    created_at = models.DateTimeField(auto_now_add=True)
-    updated_at = models.DateTimeField(auto_now=True)
-    is_deleted = models.BooleanField(default=False)
-
-    class Meta:
-        abstract = True
-        ordering = ['-created_at']
-
-    def soft_delete(self) -> None:
-        """Soft delete the record."""
-        self.is_deleted = True
-        self.save(update_fields=['is_deleted', 'updated_at'])
-
-    def restore(self) -> None:
-        """Restore a soft-deleted record."""
-        self.is_deleted = False
-        self.save(update_fields=['is_deleted', 'updated_at'])
-```
-
-### Step 2: Inherit from BaseModel
-
-```python
-# users/models.py
-from django.db import models
-import core.models as _core_models
-
-class User(_core_models.BaseModel):
-    """User model - inherits id, timestamps, soft delete from BaseModel."""
-
-    email = models.EmailField(unique=True, db_index=True)
-    first_name = models.CharField(max_length=100)
-    last_name = models.CharField(max_length=100)
-
-    class Meta:
-        db_table = 'users'
-        verbose_name = 'User'
-        verbose_name_plural = 'Users'
-```
-
-## Wrong vs Right
-
-```python
-# ❌ WRONG - Repeating fields that should come from BaseModel
-class Product(models.Model):
-    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
-    created_at = models.DateTimeField(auto_now_add=True)
-    updated_at = models.DateTimeField(auto_now=True)
-    is_deleted = models.BooleanField(default=False)
-    name = models.CharField(max_length=255)
-
-# ✅ CORRECT - Inherit from BaseModel
-import core.models as _core_models
-
-class Product(_core_models.BaseModel):
-    """Product model."""
-    name = models.CharField(max_length=255)
-    price = models.DecimalField(max_digits=10, decimal_places=2)
-
-    class Meta:
-        db_table = 'products'
-```
-
-## Import Pattern
-
-```python
-# ✅ CORRECT - Absolute import with alias
-import core.models as _core_models
-
-class MyModel(_core_models.BaseModel):
-    pass
-
-# ❌ WRONG - Relative import
-from .base import BaseModel
-```
-
-## Custom Managers
-
-For soft delete support:
-
-```python
-class ActiveManager(models.Manager):
-    def get_queryset(self):
-        return super().get_queryset().filter(is_deleted=False)
-
-class Product(_core_models.BaseModel):
-    name = models.CharField(max_length=255)
-
-    objects = ActiveManager()  # Default: excludes deleted
-    all_objects = models.Manager()  # Include deleted
-```
-
-## Field Naming Conventions
-
-- Use snake_case for all field names
-- Boolean fields: `is_*` or `has_*` prefix
-- DateTime fields: `*_at` suffix
-- Foreign keys: descriptive name (not `{model}_id`)
-
-```python
-# ✅ CORRECT
-is_active = models.BooleanField()
-published_at = models.DateTimeField()
-author = models.ForeignKey(User, on_delete=models.CASCADE)
-
-# ❌ WRONG
-active = models.BooleanField()  # No prefix
-publishedAt = models.DateTimeField()  # camelCase
-```
-
-## Meta Options
-
-Always define:
-
-```python
-class Meta:
-    db_table = 'products'  # Explicit table name
-    ordering = ['-created_at']  # Default ordering
-    verbose_name = 'Product'
-    verbose_name_plural = 'Products'
-    indexes = [
-        models.Index(fields=['name']),
-    ]
-```
-
-## Forbidden Patterns
-
-- `models.AutoField` - BaseModel uses UUID
-- `id = models.UUIDField(...)` in non-base models - Inherit from BaseModel
-- `created_at = ...` in non-base models - Inherit from BaseModel
-- Hard deletes - Use `soft_delete()` method
-- Business logic in models - Use service layer