# Directly invoke a skill
AgileFlow:acceptance-criteria-generator

# Agents use skills automatically
@agileflow-api implement login endpoint
# API agent uses type-definitions and validation-schema-generator skills

Input: "User login with email and password"
 
Output:
**Given** I am on the login page
**When** I enter valid email and password
**Then** I should be logged in and redirected to dashboard
 
**Given** I enter invalid credentials
**When** I submit the form
**Then** I should see an error message

# ADR-001: Use PostgreSQL for Database
 
## Status
Accepted
 
## Context
We need a reliable database with ACID guarantees for user data.
 
## Decision
Use PostgreSQL 15 as primary database.
 
## Consequences
**Positive**: Strong consistency, JSON support
**Negative**: More complex than SQLite
**Neutral**: Team needs PostgreSQL training
 
## Alternatives
- MySQL: Less JSON support
- MongoDB: No ACID guarantees
- SQLite: Not scalable

## Summary
Implements user login functionality (AF-001)
 
## Changes
- Added /api/login endpoint
- Created LoginForm component
- Added JWT authentication
- Implemented session management
 
## Testing
1. Navigate to /login
2. Enter credentials
3. Verify successful login
4. Check session persists
 
## Checklist
- [x] Tests passing
- [x] Docs updated
- [x] No breaking changes
- [x] Accessibility checked

## [1.2.0] - 2024-01-15
 
### Added
- User login with JWT authentication
- Password reset via email
- Two-factor authentication support
 
### Changed
- Updated session timeout to 24 hours
- Improved login error messages
 
### Fixed
- Session not persisting after page reload
- Email validation regex

// Input: User object from API
{
  id: 1,
  email: "user@example.com",
  name: "John Doe",
  createdAt: "2024-01-01T00:00:00Z"
}
 
// Output:
interface User {
  id: number;
  email: string;
  name: string;
  createdAt: string;
}
 
type UserResponse = {
  data: User;
  meta: {
    timestamp: string;
  };
};

import { z } from 'zod';
 
const loginSchema = z.object({
  email: z.string().email('Invalid email'),
  password: z.string().min(8, 'Password must be 8+ chars'),
  rememberMe: z.boolean().optional(),
});
 
type LoginInput = z.infer<typeof loginSchema>;

class AuthenticationError extends Error {
  constructor(message: string) {
    super(message);
    this.name = 'AuthenticationError';
  }
}
 
const handleError = (error: Error) => {
  if (error instanceof AuthenticationError) {
    return { status: 401, message: 'Invalid credentials' };
  }
  // ... other error types
  return { status: 500, message: 'Internal error' };
};

-- Migration: create_users_table
 
-- Up
CREATE TABLE users (
  id SERIAL PRIMARY KEY,
  email VARCHAR(255) UNIQUE NOT NULL,
  password_hash VARCHAR(255) NOT NULL,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
 
CREATE INDEX idx_users_email ON users(email);
 
-- Down
DROP INDEX idx_users_email;
DROP TABLE users;

describe('User Login', () => {
  it('should log in with valid credentials', async () => {
    const user = await login('user@example.com', 'password123');
    expect(user).toBeDefined();
    expect(user.email).toBe('user@example.com');
  });
 
  it('should reject invalid credentials', async () => {
    await expect(
      login('user@example.com', 'wrong')
    ).rejects.toThrow('Invalid credentials');
  });
 
  it('should require email format', async () => {
    await expect(
      login('invalid-email', 'password123')
    ).rejects.toThrow('Invalid email');
  });
});

sequenceDiagram
    participant User
    participant Frontend
    participant API
    participant Database
 
    User->>Frontend: Enter credentials
    Frontend->>API: POST /api/login
    API->>Database: Query user
    Database-->>API: User data
    API-->>Frontend: JWT token
    Frontend-->>User: Redirect to dashboard

## Migration Checklist: User Table Schema Update
 
### Pre-Migration
- [ ] Backup production database
- [ ] Test migration on staging
- [ ] Notify team of maintenance window
- [ ] Verify rollback script
 
### Migration
- [ ] Set application to maintenance mode
- [ ] Run migration script
- [ ] Verify row count matches
- [ ] Check for errors in logs
 
### Validation
- [ ] Query sample data
- [ ] Run automated tests
- [ ] Verify foreign key constraints
- [ ] Check application functionality
 
### Rollback (if needed)
- [ ] Run rollback script
- [ ] Restore from backup
- [ ] Verify data integrity

feat(auth): implement user login

- Added /api/login endpoint
- Created JWT token generation
- Implemented session management

Closes #123

# Use multiple skills together
1. story-skeleton → Generate story structure
2. acceptance-criteria-generator → Add criteria
3. test-case-generator → Create tests
4. type-definitions → Define types
5. validation-schema-generator → Add validation

@agileflow-api implement user registration

Agent uses:
- type-definitions (User type)
- validation-schema-generator (input validation)
- error-handler-template (error handling)
- test-case-generator (unit tests)
- api-documentation-generator (OpenAPI spec)

<!-- .claude/skills/my-custom-skill.md -->
 
# My Custom Skill
 
**Input**: {{input_description}}
**Output**: {{output_description}}
 
**Template**:
\```typescript
// Generated code here
\```

1. Create story → story-skeleton
2. Add criteria → acceptance-criteria-generator
3. Define types → type-definitions
4. Generate tests → test-case-generator

API endpoint implementation:
1. type-definitions → Data models
2. validation-schema-generator → Input validation
3. api-documentation-generator → OpenAPI spec
4. test-case-generator → Test suite
5. error-handler-template → Error handling