From Spec to Working Code

gemini "@spec/recurring-tasks.json @models.py @database.py
Implement the RecurringTask SQLAlchemy model following the spec.
The spec is in recurring-tasks.json under 'new_models'.

Requirements:
- Match the import style at the top of models.py exactly
- Use Column(DateTime(timezone=True), server_default=func.now()) for timestamps
- Add relationship() to the existing Task class using back_populates
- Add cascade='all, delete-orphan' to mirror the User.tasks pattern

Output: the complete RecurringTask class definition + the 2 lines
to add to the Task class. Python only, no markdown." >> models.py

gemini "@schemas.py @spec/recurring-tasks.json
Add Pydantic v2 schemas for the RecurringTask model.
The spec defines the fields under 'new_models[0].fields'.

Requirements:
- Create RecurringTaskCreate (schedule_type, interval_value)
- Create RecurringTask response schema (all fields + model_config)
- Follow the exact pattern of TagBase / TagCreate / Tag (lines 7-16 of schemas.py)
  - Use model_config = {'from_attributes': True} on the response schema
  - Keep the three-schema pattern: Base → Create → Response

Output: the three schema classes. Python only." >> schemas.py

gemini "@routers/ @models.py @schemas.py @spec/recurring-tasks.json
Create a new file routers/recurrence.py with three endpoints from the spec:
  POST   /tasks/{task_id}/recurrence
  GET    /tasks/{task_id}/recurrence
  DELETE /tasks/{task_id}/recurrence

Follow ALL patterns from the existing routers/:
- Router prefix and tags declaration style (see routers/tasks.py line 9)
- Auth: use Depends(get_current_user) on every endpoint
- Query pattern: db.query(Model).filter(...).first() — not ORM session style
- 404 handling: raise HTTPException(status_code=404, detail='...')
- Owner validation: only the task owner can manage its recurrence
- Response models: use schemas.RecurringTask and schemas.RecurringTaskCreate

Output the complete routers/recurrence.py file. Python only." \
  > routers/recurrence.py

from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from datetime import datetime, timedelta, timezone

from database import get_db
from auth import get_current_user
import models, schemas

router = APIRouter(prefix="/tasks", tags=["recurrence"])


@router.post("/{task_id}/recurrence",
             response_model=schemas.RecurringTask,
             status_code=201)
def create_recurrence(
    task_id: int,
    recurrence: schemas.RecurringTaskCreate,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user),
):
    # Verify task exists and belongs to the current user
    task = db.query(models.Task).filter(
        models.Task.id == task_id,
        models.Task.owner_id == current_user.id,
    ).first()
    if not task:
        raise HTTPException(status_code=404, detail="Task not found")

    # Prevent duplicate recurrences
    if db.query(models.RecurringTask).filter(
        models.RecurringTask.task_id == task_id
    ).first():
        raise HTTPException(status_code=400, detail="Recurrence already exists")

    # Calculate first next_run_at based on schedule_type
    now = datetime.now(tz=timezone.utc)
    if recurrence.schedule_type == "daily":
        next_run = now + timedelta(days=recurrence.interval_value or 1)
    elif recurrence.schedule_type == "weekly":
        next_run = now + timedelta(weeks=recurrence.interval_value or 1)
    else:  # monthly
        next_run = now + timedelta(days=30 * (recurrence.interval_value or 1))

    db_rec = models.RecurringTask(
        task_id=task_id,
        schedule_type=recurrence.schedule_type,
        interval_value=recurrence.interval_value,
        next_run_at=next_run,
    )
    db.add(db_rec)
    db.commit()
    db.refresh(db_rec)
    return db_rec


@router.get("/{task_id}/recurrence", response_model=schemas.RecurringTask)
def get_recurrence(
    task_id: int,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user),
):
    task = db.query(models.Task).filter(
        models.Task.id == task_id,
        models.Task.owner_id == current_user.id,
    ).first()
    if not task:
        raise HTTPException(status_code=404, detail="Task not found")

    rec = db.query(models.RecurringTask).filter(
        models.RecurringTask.task_id == task_id
    ).first()
    if not rec:
        raise HTTPException(status_code=404, detail="No recurrence set for this task")
    return rec


@router.delete("/{task_id}/recurrence", status_code=204)
def delete_recurrence(
    task_id: int,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user),
):
    task = db.query(models.Task).filter(
        models.Task.id == task_id,
        models.Task.owner_id == current_user.id,
    ).first()
    if not task:
        raise HTTPException(status_code=404, detail="Task not found")

    rec = db.query(models.RecurringTask).filter(
        models.RecurringTask.task_id == task_id
    ).first()
    if not rec:
        raise HTTPException(status_code=404, detail="No recurrence to delete")
    db.delete(rec)
    db.commit()

gemini "@main.py @routers/recurrence.py
Show me the minimal diff to wire the new recurrence router into main.py.
Follow the exact pattern used to add tasks and tags routers.
Output only the 2 lines to add — the import and the app.include_router() call."

# Line to add at top with other router imports:
from routers import users, tasks, tags, recurrence

# Line to add after app.include_router(tags.router):
app.include_router(recurrence.router)

# TaskFlow's query pattern — always:
task = db.query(models.Task).filter(
    models.Task.id == task_id,
    models.Task.owner_id == current_user.id,
).first()

# NOT the SQLAlchemy 2.0 session.execute() style:
# result = db.execute(select(models.Task).where(...))  # ← Gemini avoided this
# task = result.scalar_one_or_none()  # ← Gemini avoided this

# TaskFlow's schema pattern — every response schema has:
class RecurringTask(RecurringTaskBase):
    id: int
    task_id: int
    next_run_at: datetime
    is_active: bool
    created_at: datetime
    model_config = {"from_attributes": True}  # ← Pydantic v2 ORM mode

# NOT the Pydantic v1 style:
# class Config:
#     orm_mode = True  # ← Gemini avoided this deprecated pattern

# Every protected endpoint in TaskFlow uses:
current_user: models.User = Depends(get_current_user)

# And verifies ownership before any operation:
task = db.query(models.Task).filter(
    models.Task.id == task_id,
    models.Task.owner_id == current_user.id,  # ← ownership check baked into query
).first()
if not task:
    raise HTTPException(status_code=404, detail="Task not found")
# Note: returns 404, not 403 — intentional: don't reveal that the task exists

# Stage the new files
git add routers/recurrence.py models.py schemas.py main.py

# Generate the commit message from the actual staged diff
$diff = git diff --staged --stat
gemini "Write a conventional commit message for these staged changes:
$diff

The change adds recurring task support to TaskFlow.
Format: type(scope): short summary (max 72 chars)
Followed by a blank line and a 2-3 sentence body explaining WHY,
not just WHAT. Use 'feat' type."

feat(recurrence): add recurring task schedule endpoints

Adds POST/GET/DELETE /tasks/{id}/recurrence endpoints to TaskFlow via
a new routers/recurrence.py module. Introduces the RecurringTask SQLAlchemy
model (one-to-one with Task) and corresponding Pydantic v2 schemas.

The RecurringTask model stores schedule_type (daily/weekly/monthly),
interval_value, and next_run_at so the background scheduler can poll
for due tasks without modifying existing task CRUD logic.

Co-authored-by: Gemini CLI

gemini "@routers/recurrence.py @routers/tasks.py @models.py
Review routers/recurrence.py before I open a PR.
Check for:
1. Auth: is every endpoint protected with get_current_user?
2. Ownership: does every endpoint verify task.owner_id == current_user.id?
3. Error handling: are all 404 cases covered?
4. Consistency: does it follow the same patterns as tasks.py?
5. Edge cases: what happens if task_id doesn't exist vs. recurrence doesn't exist?
List specific issues with line numbers if you find any."

# Run tests and capture output
pytest tests/ -v 2>&1 | Tee-Object test-output.txt

# Feed the error to Gemini with context
$err = Get-Content test-output.txt | Select-Object -Last 30
gemini "@routers/recurrence.py @schemas.py @models.py
This test failure occurred after implementing recurrence.py:

$err

Identify the root cause and show the minimal code change to fix it.
Reference specific line numbers in the affected file."

# Error: ImportError: cannot import name 'RecurringTaskCreate' from 'schemas'
gemini "@schemas.py @routers/recurrence.py
recurrence.py imports schemas.RecurringTaskCreate but it doesn't exist in schemas.py.
Add the RecurringTaskCreate and RecurringTask schemas following the
Tag/TagCreate/TagBase pattern (lines 7-16 of schemas.py).
Output only the new schema classes."

# Error: 404 on POST /tasks/1/recurrence (router not registered)
gemini "@main.py
I get 404 on the recurrence endpoints. The router is in routers/recurrence.py
but the /docs page doesn't show the endpoints.
Show the 2 lines to add to main.py to register it — follow the tasks/tags pattern."

# Error: can't compare offset-naive and offset-aware datetimes
gemini "@routers/recurrence.py
Line X calculates next_run_at using datetime.now() which returns
a naive datetime. The next_run_at column is DateTime(timezone=True).
Fix the line to use datetime.now(tz=timezone.utc) instead."