cc-codeconductor 0.4.3 → 0.5.0

package/presets/cursor/skills/django-uv/SKILL.md

@@ -0,0 +1,409 @@
+---
+id: django-uv
+version: 1.0.0
+name: Django + UV
+description: >
+  Provides expert knowledge for building Django 5+ projects with UV as the package manager, domain-driven app structure, ruff for linting, and pytest-django for testing.
+
+user-invokable: true
+license: MIT
+metadata:
+  author: lgzarturo
+  category: django
+
+compatibility:
+  tools: [claude, codex, gemini, agy, opencode]
+  stacks:
+    languages: []
+    frameworks: []
+
+risk:
+  level: medium
+  can_execute_shell: false
+  can_modify_files: true
+  requires_network: false
+
+inputs: []
+
+outputs: []
+
+quality:
+  reviewed_by: codeconductor-core
+  version: 0.1.0
+paths:
+  - "**/pyproject.toml"
+  - "**/uv.lock"
+---
+
+
+
+# Django + UV
+
+## Project Setup with UV
+
+UV replaces pip, pip-tools, virtualenv, and pyenv in a single binary. Always
+use UV for dependency management.
+
+```bash
+# Create project
+uv init my-project
+cd my-project
+
+# Add Django and dependencies
+uv add django psycopg[binary] djangorestframework django-environ
+
+# Add dev dependencies
+uv add --dev pytest pytest-django ruff factory-boy coverage
+
+# Run management commands
+uv run python manage.py migrate
+uv run python manage.py runserver
+```
+
+### pyproject.toml Layout
+
+```toml
+[project]
+name = "my-project"
+version = "0.1.0"
+requires-python = ">=3.12"
+dependencies = [
+    "django>=5.0",
+    "psycopg[binary]>=3.1",
+    "djangorestframework>=3.15",
+    "django-environ>=0.11",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-django>=4.8",
+    "ruff>=0.4",
+    "factory-boy>=3.3",
+    "coverage>=7.4",
+]
+
+[tool.ruff]
+line-length = 88
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "N", "UP", "B", "SIM"]
+ignore = ["E501"]
+
+[tool.pytest.ini_options]
+DJANGO_SETTINGS_MODULE = "config.settings.test"
+python_files = ["test_*.py", "*_test.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+
+[tool.coverage.run]
+source = ["."]
+omit = ["*/migrations/*", "*/tests/*", "manage.py"]
+```
+
+## App Structure (Domain-Driven)
+
+Organize by domain, not by technical layer. Each Django app owns its domain
+entirely.
+
+```text
+my_project/
+  config/
+    settings/
+      base.py       — shared settings
+      dev.py        — local overrides
+      test.py       — test-specific settings
+      prod.py       — production settings
+    urls.py
+    wsgi.py
+  apps/
+    users/
+      models.py
+      services.py   — business logic, never in views
+      views.py      — thin; delegates to services
+      serializers.py
+      admin.py
+      urls.py
+      tests/
+        test_models.py
+        test_services.py
+        test_views.py
+        factories.py
+    orders/
+      ...
+  manage.py
+  pyproject.toml
+```
+
+## Settings Split
+
+```python
+# config/settings/base.py
+from pathlib import Path
+import environ
+
+env = environ.Env()
+BASE_DIR = Path(__file__).resolve().parent.parent.parent
+
+SECRET_KEY = env("SECRET_KEY")
+DEBUG = env.bool("DEBUG", default=False)
+
+INSTALLED_APPS = [
+    "django.contrib.admin",
+    "django.contrib.auth",
+    "django.contrib.contenttypes",
+    "rest_framework",
+    "apps.users",
+    "apps.orders",
+]
+
+DATABASES = {
+    "default": env.db("DATABASE_URL")
+}
+```
+
+```python
+# config/settings/test.py
+from .base import *  # noqa: F403
+
+DATABASES = {
+    "default": {
+        "ENGINE": "django.db.backends.sqlite3",
+        "NAME": ":memory:",
+    }
+}
+
+# Never send real emails in tests
+EMAIL_BACKEND = "django.core.mail.backends.locmem.EmailBackend"
+```
+
+## Models
+
+```python
+# apps/users/models.py
+import uuid
+from django.db import models
+from django.contrib.auth.models import AbstractUser
+
+
+class User(AbstractUser):
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    email = models.EmailField(unique=True)
+    bio = models.TextField(blank=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    USERNAME_FIELD = "email"
+    REQUIRED_FIELDS = ["username"]
+
+    class Meta:
+        ordering = ["-created_at"]
+
+    def __str__(self) -> str:
+        return self.email
+```
+
+Rules:
+
+- Use UUID primary keys — never expose sequential integer IDs in public APIs
+- `auto_now_add` and `auto_now` for timestamps — never set manually
+- Always define `__str__` — it appears in admin and error messages
+- Use `blank=True` for optional strings (form validation), `null=True` only for
+  nullable FK/non-string fields
+
+## Service Layer
+
+Business logic lives in `services.py`. Views are thin HTTP adapters.
+
+```python
+# apps/users/services.py
+from django.db import transaction
+from django.contrib.auth.hashers import make_password
+from .models import User
+
+
+class UserService:
+
+    @staticmethod
+    def create_user(*, email: str, password: str, username: str) -> User:
+        if User.objects.filter(email=email).exists():
+            raise ValueError(f"Email {email!r} is already registered")
+
+        with transaction.atomic():
+            user = User.objects.create(
+                email=email,
+                username=username,
+                password=make_password(password),
+            )
+        return user
+
+    @staticmethod
+    def deactivate_user(*, user_id: str) -> User:
+        user = User.objects.get(id=user_id)
+        user.is_active = False
+        user.save(update_fields=["is_active", "updated_at"])
+        return user
+```
+
+Rules:
+
+- Use keyword-only arguments (`*` separator) in service methods — prevents
+  positional argument confusion
+- Use `update_fields` in `save()` — avoids overwriting unintended fields and
+  reduces the UPDATE query scope
+- Wrap multi-step writes in `transaction.atomic()`
+- Never import from `views.py` in `services.py` — keep the dependency direction
+  strict: views → services → models
+
+## Views (DRF)
+
+```python
+# apps/users/views.py
+from rest_framework import status
+from rest_framework.decorators import api_view, permission_classes
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.request import Request
+from rest_framework.response import Response
+
+from .serializers import CreateUserSerializer, UserSerializer
+from .services import UserService
+
+
+@api_view(["POST"])
+def create_user(request: Request) -> Response:
+    serializer = CreateUserSerializer(data=request.data)
+    serializer.is_valid(raise_exception=True)
+
+    user = UserService.create_user(**serializer.validated_data)
+    return Response(UserSerializer(user).data, status=status.HTTP_201_CREATED)
+
+
+@api_view(["DELETE"])
+@permission_classes([IsAuthenticated])
+def deactivate_user(request: Request, user_id: str) -> Response:
+    UserService.deactivate_user(user_id=user_id)
+    return Response(status=status.HTTP_204_NO_CONTENT)
+```
+
+## Testing with pytest-django
+
+### Test Factories
+
+```python
+# apps/users/tests/factories.py
+import factory
+from factory.django import DjangoModelFactory
+from apps.users.models import User
+
+
+class UserFactory(DjangoModelFactory):
+    class Meta:
+        model = User
+
+    email = factory.Sequence(lambda n: f"user{n}@example.com")
+    username = factory.Sequence(lambda n: f"user{n}")
+    password = factory.PostGenerationMethodCall("set_password", "testpass123")
+    is_active = True
+```
+
+### Service Tests
+
+```python
+# apps/users/tests/test_services.py
+import pytest
+from apps.users.services import UserService
+
+
+@pytest.mark.django_db
+class TestUserService:
+
+    def test_create_user_succeeds_with_valid_data(self):
+        user = UserService.create_user(
+            email="new@example.com",
+            password="secure123",
+            username="newuser",
+        )
+
+        assert user.pk is not None
+        assert user.email == "new@example.com"
+        assert user.check_password("secure123")
+
+    def test_create_user_raises_when_email_exists(self, user_factory):
+        existing = user_factory(email="taken@example.com")
+
+        with pytest.raises(ValueError, match="already registered"):
+            UserService.create_user(
+                email=existing.email,
+                password="any",
+                username="other",
+            )
+```
+
+### View Tests
+
+```python
+# apps/users/tests/test_views.py
+import pytest
+from django.urls import reverse
+
+
+@pytest.mark.django_db
+class TestCreateUser:
+
+    def test_returns_201_with_valid_payload(self, client):
+        response = client.post(
+            reverse("users:create"),
+            data={"email": "new@example.com", "password": "secure123", "username": "new"},
+            content_type="application/json",
+        )
+
+        assert response.status_code == 201
+        assert response.data["email"] == "new@example.com"
+
+    def test_returns_400_with_invalid_email(self, client):
+        response = client.post(
+            reverse("users:create"),
+            data={"email": "not-an-email", "password": "x", "username": "y"},
+            content_type="application/json",
+        )
+
+        assert response.status_code == 400
+
+    def test_returns_400_when_email_already_exists(self, client, user_factory):
+        user_factory(email="taken@example.com")
+
+        response = client.post(
+            reverse("users:create"),
+            data={"email": "taken@example.com", "password": "pass", "username": "z"},
+            content_type="application/json",
+        )
+
+        assert response.status_code == 400
+```
+
+### conftest.py
+
+```python
+# conftest.py
+import pytest
+from pytest_factoryboy import register
+from apps.users.tests.factories import UserFactory
+
+register(UserFactory)   # makes user_factory fixture available everywhere
+```
+
+## Linting
+
+```bash
+# Check
+uv run ruff check .
+
+# Fix auto-fixable issues
+uv run ruff check --fix .
+
+# Format
+uv run ruff format .
+```
+
+Run ruff in CI on every pull request. Do not merge code that fails lint.

package/presets/cursor/skills/drizzle-schema-architect/SKILL.md

@@ -0,0 +1,54 @@
+---
+id: drizzle-schema-architect
+version: 1.0.0
+name: Drizzle Schema Architect
+description: >
+  Generates strictly typed Drizzle ORM schemas for PostgreSQL with indexes, 
+  foreign keys, and Zod schema deduction.
+user-invokable: true
+license: MIT
+metadata:
+  author: lgzarturo
+  category: database
+compatibility:
+  tools: [claude, codex, gemini, agy, opencode]
+  stacks:
+    languages: [typescript, javascript]
+    frameworks: [nextjs, drizzle]
+    databases: [postgresql]
+paths:
+  - "**/schema.ts"
+  - "**/drizzle/**"
+---
+# Drizzle Schema Architect
+
+## Core Principles
+
+1. **Strict Typing**: All table columns must be explicitly typed. Do not rely on loose implicit types.
+2. **PostgreSQL Focus**: Use pg-specific column types (e.g. `pgTable`, `uuid`, `timestamp`, `varchar`, `integer`).
+3. **Zod Validation Integration**: Always output Zod schemas inferred from Drizzle schemas using `drizzle-zod`'s `createInsertSchema` and `createSelectSchema`.
+
+## Schema Guidelines
+
+- **Primary Keys**: Prefer UUIDs generated by `gen_random_uuid()` or autoincrementing integers depending on the table volume.
+- **Indices**: Declare explicit indexes on foreign key columns and query filters.
+- **Dates**: Always store timestamps using `timestamp('created_at', { withTimezone: true, mode: 'date' }).defaultNow().notNull()`.
+
+### Example Schema Pattern
+
+```typescript
+import { pgTable, uuid, varchar, timestamp, index } from 'drizzle-orm/pg-core';
+import { createInsertSchema, createSelectSchema } from 'drizzle-zod';
+
+export const users = pgTable('users', {
+  id: uuid('id').defaultRandom().primaryKey(),
+  email: varchar('email', { length: 255 }).notNull().unique(),
+  name: varchar('name', { length: 255 }),
+  createdAt: timestamp('created_at', { withTimezone: true, mode: 'date' }).defaultNow().notNull(),
+}, (table) => [
+  index('email_idx').on(table.email)
+]);
+
+export const insertUserSchema = createInsertSchema(users);
+export const selectUserSchema = createSelectSchema(users);
+```

package/presets/cursor/skills/evaluation/SKILL.md

@@ -0,0 +1,8 @@
+---
+name: evaluation
+description: Scorecard, outcomes, model profiles. Use with /cc-scorecard.
+
+disable-model-invocation: true
+---
+
+See `presets/claude/skills/evaluation/SKILL.md` for full evaluation workflow.

package/presets/cursor/skills/fastapi-pydantic-strict/SKILL.md

@@ -0,0 +1,46 @@
+---
+id: fastapi-pydantic-strict
+version: 1.0.0
+name: FastAPI Pydantic Strict
+description: >
+  Enforces Pydantic v2 strict models, asynchronous dependency generators, and uv environment setup.
+user-invokable: true
+license: MIT
+metadata:
+  author: lgzarturo
+  category: validation
+compatibility:
+  tools: [claude, codex, gemini, agy, opencode]
+  stacks:
+    languages: [python]
+    frameworks: [fastapi, pydantic]
+paths:
+  - "**/*.py"
+---
+# FastAPI Pydantic Strict
+
+## Core Principles
+
+1. **Pydantic v2 Model Configuration**: Always configure models with `model_config = ConfigDict(strict=True)` to enforce type correctness.
+2. **Async Dependencies**: Rely on async FastAPI dependency generators (`async def get_db()`) to handle context managers correctly.
+3. **Environment Management**: Use `uv` for lightning-fast package installs and lockfile consistency.
+
+## Code Blueprint
+
+```python
+from fastapi import FastAPI, Depends
+from pydantic import BaseModel, ConfigDict, Field
+
+app = FastAPI()
+
+class StrictUser(BaseModel):
+    model_config = ConfigDict(strict=True)
+    
+    id: int
+    name: str = Field(..., min_length=2)
+    email: str
+
+@app.post("/users", response_model=StrictUser)
+async def create_user(user: StrictUser):
+    return user
+```

package/presets/cursor/skills/find-skills/SKILL.md

@@ -0,0 +1,144 @@
+---
+name: find-skills
+description: Helps users discover and install agent skills when they ask questions like "how do I do X", "find a skill for X", "is there a skill that can...", or express interest in extending capabilities. This skill should be used when the user is looking for functionality that might exist as an installable skill.
+
+disable-model-invocation: true
+---
+
+# Find Skills
+
+This skill helps you discover and install skills from the open agent skills ecosystem.
+
+## When to Use This Skill
+
+Use this skill when the user:
+
+- Asks "how do I do X" where X might be a common task with an existing skill
+- Says "find a skill for X" or "is there a skill for X"
+- Asks "can you do X" where X is a specialized capability
+- Expresses interest in extending agent capabilities
+- Wants to search for tools, templates, or workflows
+- Mentions they wish they had help with a specific domain (design, testing, deployment, etc.)
+
+## What is the Skills CLI?
+
+The Skills CLI (`npx skills`) is the package manager for the open agent skills ecosystem. Skills are modular packages that extend agent capabilities with specialized knowledge, workflows, and tools.
+
+**Key commands:**
+
+- `npx skills find [query]` - Search for skills interactively or by keyword
+- `npx skills add <package>` - Install a skill from GitHub or other sources
+- `npx skills check` - Check for skill updates
+- `npx skills update` - Update all installed skills
+
+**Browse skills at:** https://skills.sh/
+
+## How to Help Users Find Skills
+
+### Step 1: Understand What They Need
+
+When a user asks for help with something, identify:
+
+1. The domain (e.g., React, testing, design, deployment)
+2. The specific task (e.g., writing tests, creating animations, reviewing PRs)
+3. Whether this is a common enough task that a skill likely exists
+
+### Step 2: Check the Leaderboard First
+
+Before running a CLI search, check the [skills.sh leaderboard](https://skills.sh/) to see if a well-known skill already exists for the domain. The leaderboard ranks skills by total installs, surfacing the most popular and battle-tested options.
+
+For example, top skills for web development include:
+- `vercel-labs/agent-skills` — React, Next.js, web design (100K+ installs each)
+- `anthropics/skills` — Frontend design, document processing (100K+ installs)
+
+### Step 3: Search for Skills
+
+If the leaderboard doesn't cover the user's need, run the find command:
+
+```bash
+npx skills find [query]
+```
+
+For example:
+
+- User asks "how do I make my React app faster?" → `npx skills find react performance`
+- User asks "can you help me with PR reviews?" → `npx skills find pr review`
+- User asks "I need to create a changelog" → `npx skills find changelog`
+
+### Step 4: Verify Quality Before Recommending
+
+**Do not recommend a skill based solely on search results.** Always verify:
+
+1. **Install count** — Prefer skills with 1K+ installs. Be cautious with anything under 100.
+2. **Source reputation** — Official sources (`vercel-labs`, `anthropics`, `microsoft`) are more trustworthy than unknown authors.
+3. **GitHub stars** — Check the source repository. A skill from a repo with <100 stars should be treated with skepticism.
+
+### Step 5: Present Options to the User
+
+When you find relevant skills, present them to the user with:
+
+1. The skill name and what it does
+2. The install count and source
+3. The install command they can run
+4. A link to learn more at skills.sh
+
+Example response:
+
+```
+I found a skill that might help! The "react-best-practices" skill provides
+React and Next.js performance optimization guidelines from Vercel Engineering.
+(185K installs)
+
+To install it:
+npx skills add vercel-labs/agent-skills@react-best-practices
+
+Learn more: https://skills.sh/vercel-labs/agent-skills/react-best-practices
+```
+
+### Step 6: Offer to Install
+
+If the user wants to proceed, you can install the skill for them:
+
+```bash
+npx skills add <owner/repo@skill> -g -y
+```
+
+The `-g` flag installs globally (user-level) and `-y` skips confirmation prompts.
+
+## Common Skill Categories
+
+When searching, consider these common categories:
+
+| Category        | Example Queries                          |
+| --------------- | ---------------------------------------- |
+| Web Development | react, nextjs, typescript, css, tailwind |
+| Testing         | testing, jest, playwright, e2e           |
+| DevOps          | deploy, docker, kubernetes, ci-cd        |
+| Documentation   | docs, readme, changelog, api-docs        |
+| Code Quality    | review, lint, refactor, best-practices   |
+| Design          | ui, ux, design-system, accessibility     |
+| Productivity    | workflow, automation, git                |
+
+## Tips for Effective Searches
+
+1. **Use specific keywords**: "react testing" is better than just "testing"
+2. **Try alternative terms**: If "deploy" doesn't work, try "deployment" or "ci-cd"
+3. **Check popular sources**: Many skills come from `vercel-labs/agent-skills` or `ComposioHQ/awesome-claude-skills`
+
+## When No Skills Are Found
+
+If no relevant skills exist:
+
+1. Acknowledge that no existing skill was found
+2. Offer to help with the task directly using your general capabilities
+3. Suggest the user could create their own skill with `npx skills init`
+
+Example:
+
+```
+I searched for skills related to "xyz" but didn't find any matches.
+I can still help you with this task directly! Would you like me to proceed?
+
+If this is something you do often, you could create your own skill:
+npx skills init my-xyz-skill
+```

package/presets/cursor/skills/jpa-nplusone-detector/SKILL.md

@@ -0,0 +1,49 @@
+---
+id: jpa-nplusone-detector
+version: 1.0.0
+name: JPA N+1 Query Detector
+description: >
+  Audits Hibernate database interactions to prevent N+1 query problems in JVM apps.
+user-invokable: true
+license: MIT
+metadata:
+  author: lgzarturo
+  category: performance
+compatibility:
+  tools: [claude, codex, gemini, agy, opencode]
+  stacks:
+    languages: [kotlin, java]
+    frameworks: [spring-boot, spring-data-jpa, hibernate]
+paths:
+  - "**/*.kt"
+  - "**/*.java"
+---
+# JPA N+1 Query Detector
+
+## Core Principles
+
+1. **Hibernate Fetches**: Avoid lazy-loading relationships within loops or stream operations.
+2. **Batch Fetching & Joins**: Resolve N+1 issues by using `@EntityGraph` or `JOIN FETCH` inside custom JPQL queries.
+3. **Hibernate Statistics**: Enable Hibernate statistics in development to verify query counts.
+
+## Remediation Patterns
+
+### Ineffective Pattern (Triggers N+1 queries)
+```kotlin
+val users = userRepository.findAll()
+for (user in users) {
+    println(user.posts.size) // Post is loaded lazily for each user
+}
+```
+
+### Remediation A: Using JOIN FETCH
+```kotlin
+@Query("SELECT u FROM User u LEFT JOIN FETCH u.posts")
+fun findAllWithPosts(): List<User>
+```
+
+### Remediation B: Using @EntityGraph
+```kotlin
+@EntityGraph(attributePaths = ["posts"])
+override fun findAll(): List<User>
+```