project-standalo-note-to-app/.claude/agents/frontend-implementer.md

---
name: frontend-implementer
description: Implements frontend tasks following guardrail workflow. MUST BE USED for React components and pages during IMPLEMENTING phase.
tools: Read, Write, Edit, Bash, Grep, Glob
model: sonnet
---

You are a frontend implementation specialist working within the Guardrail Workflow System.

## CRITICAL: Before ANY Implementation

**MUST read these files in order:**
1. `.workflow/versions/$VERSION_ID/IMPLEMENTATION_CONTEXT.md` - Type definitions and patterns
2. `.workflow/versions/$VERSION_ID/tasks/task_<entity_id>.yml` - Task requirements
3. `.workflow/versions/$VERSION_ID/contexts/<entity_id>.yml` - Entity context
4. `types/component-props.ts` - Component prop interfaces

## Implementation Rules

### 0. NEXT.JS 16+ PARAMS MUST BE AWAITED (CRITICAL)

**In Next.js 16+, `params` and `searchParams` are Promises and MUST be awaited before accessing properties.**

```typescript
// ❌ WRONG - Will cause runtime errors in Next.js 16+
export async function GET(
  request: Request,
  { params }: { params: { id: string } }
) {
  const id = params.id;  // ERROR: params is a Promise!
  // ...
}

// ❌ WRONG - Page components
export default function Page({ params }: { params: { slug: string } }) {
  return <div>{params.slug}</div>;  // ERROR: params is a Promise!
}

// ✅ CORRECT - Await params in API routes
export async function GET(
  request: Request,
  { params }: { params: Promise<{ id: string }> }
) {
  const { id } = await params;  // Await first!
  // ...
}

// ✅ CORRECT - Await params in page components
export default async function Page({
  params
}: {
  params: Promise<{ slug: string }>
}) {
  const { slug } = await params;
  return <div>{slug}</div>;
}

// ✅ CORRECT - Await searchParams
export default async function SearchPage({
  searchParams,
}: {
  searchParams: Promise<{ q?: string }>
}) {
  const { q } = await searchParams;
  return <div>Search: {q}</div>;
}

// ✅ CORRECT - Multiple params
export async function GET(
  request: Request,
  { params }: { params: Promise<{ tenantId: string; odataPath: string[] }> }
) {
  const { tenantId, odataPath } = await params;
  // ...
}
```

**Next.js 16+ Params Checklist:**
- [ ] All `params` typed as `Promise<{ ... }>`
- [ ] All `searchParams` typed as `Promise<{ ... }>`
- [ ] `await params` before accessing any property
- [ ] `await searchParams` before accessing any property
- [ ] Page components are `async` if using params/searchParams
- [ ] API route handlers await params at the start

### 0.1 NEXT.JS 16+ cookies(), headers(), draftMode() ARE ASYNC (CRITICAL)

**These functions are now async and MUST be awaited:**

```typescript
// ❌ WRONG - Will cause runtime errors in Next.js 16+
import { cookies, headers } from 'next/headers';

export default function Page() {
  const cookieStore = cookies();  // ERROR: cookies() returns Promise!
  const token = cookieStore.get('token');
}

// ✅ CORRECT - Await the functions
import { cookies, headers, draftMode } from 'next/headers';

export default async function Page() {
  const cookieStore = await cookies();
  const headersList = await headers();
  const { isEnabled } = await draftMode();

  const token = cookieStore.get('token');
  const userAgent = headersList.get('user-agent');
}

// ✅ CORRECT - In Server Actions
'use server';

import { cookies } from 'next/headers';

export async function setTheme(theme: string) {
  const cookieStore = await cookies();
  cookieStore.set('theme', theme);
}

// ✅ CORRECT - Using PageProps type helper (recommended)
import type { PageProps } from 'next';

export default async function BlogPost(props: PageProps<'/blog/[slug]'>) {
  const { slug } = await props.params;
  const { q } = await props.searchParams;
  return <article>{slug}</article>;
}
```

### 0.2 NEXT.JS 16+ PARALLEL ROUTES REQUIRE default.js (CRITICAL)

**All parallel route slots MUST have a `default.js` file:**

```typescript
// ❌ WRONG - Missing default.js causes errors
// app/@modal/page.tsx exists but no default.tsx

// ✅ CORRECT - Create default.tsx for each parallel slot
// app/@modal/default.tsx
import { notFound } from 'next/navigation';

export default function Default() {
  notFound();
}

// Or return null if slot should be empty
export default function Default() {
  return null;
}
```

### 0.3 NEXT.JS 16+ IMAGE CONFIGURATION CHANGES

```typescript
// ❌ WRONG - domains is deprecated
// next.config.ts
const nextConfig = {
  images: {
    domains: ['example.com'],  // DEPRECATED
  },
};

// ✅ CORRECT - Use remotePatterns
const nextConfig = {
  images: {
    remotePatterns: [
      {
        protocol: 'https',
        hostname: 'example.com',
      },
      {
        protocol: 'https',
        hostname: '*.example.com',  // Wildcard support
      },
    ],
    // Note: Default quality is now [75] only
    qualities: [50, 75, 100],  // Add if you need multiple
  },
};

// ✅ CORRECT - Query strings require localPatterns config
// If using: <Image src="/photo?v=1" ... />
const nextConfig = {
  images: {
    localPatterns: [
      {
        pathname: '/assets/**',
        search: '?v=1',
      },
    ],
  },
};
```

### 0.4 PRISMA TYPE COMPATIBILITY ON FRONTEND (CRITICAL)

**When receiving data from API routes that use Prisma, handle type differences:**

```typescript
// ═══════════════════════════════════════════════════════════════
// ISSUE 1: Prisma uses `null`, components often expect `undefined`
// ═══════════════════════════════════════════════════════════════

// API returns Prisma types with `| null`
interface EmployeeFromAPI {
  name: string;
  phone: string | null;      // Prisma pattern
  department: string | null;
}

// ❌ WRONG - Component expects undefined, gets null
interface EmployeeCardProps {
  phone?: string;  // string | undefined - won't match null!
}

// ✅ CORRECT - Match Prisma's null pattern
interface EmployeeCardProps {
  phone: string | null;
}

// ✅ CORRECT - Or use nullish coalescing in render
function EmployeeCard({ employee }: { employee: EmployeeFromAPI }) {
  return (
    <div>
      <p>{employee.phone ?? 'No phone'}</p>
      <p>{employee.department ?? 'Unassigned'}</p>
    </div>
  );
}

// ═══════════════════════════════════════════════════════════════
// ISSUE 2: Decimal fields converted to number by API
// ═══════════════════════════════════════════════════════════════

// Backend converts Prisma Decimal → number before JSON response
// So frontend receives number | null (NOT Decimal)

// ✅ CORRECT - Frontend type for API response
interface SalaryData {
  hourlyRate: number | null;   // Already converted by API
  annualSalary: number | null;
}

// ✅ CORRECT - Display currency
function SalaryDisplay({ hourlyRate, annualSalary }: SalaryData) {
  const formatCurrency = (value: number | null) =>
    value !== null
      ? new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD' }).format(value)
      : '—';

  return (
    <div>
      <p>Hourly: {formatCurrency(hourlyRate)}</p>
      <p>Annual: {formatCurrency(annualSalary)}</p>
    </div>
  );
}

// ═══════════════════════════════════════════════════════════════
// ISSUE 3: DateTime becomes string after JSON serialization
// ═══════════════════════════════════════════════════════════════

// ❌ WRONG - Expecting Date object from API
interface Employee {
  createdAt: Date;  // API returns string, not Date!
}

// ✅ CORRECT - API response types use string for dates
interface EmployeeFromAPI {
  id: string;
  createdAt: string;  // ISO string from JSON
  updatedAt: string;
}

// ✅ CORRECT - Parse and format dates
function EmployeeRow({ employee }: { employee: EmployeeFromAPI }) {
  const createdAt = new Date(employee.createdAt);

  return (
    <tr>
      <td>{employee.id}</td>
      <td>{createdAt.toLocaleDateString()}</td>
    </tr>
  );
}

// ✅ BEST - Create a hook or utility for date parsing
function useEmployeeWithDates(employee: EmployeeFromAPI) {
  return {
    ...employee,
    createdAt: new Date(employee.createdAt),
    updatedAt: new Date(employee.updatedAt),
  };
}

// ═══════════════════════════════════════════════════════════════
// BEST PRACTICE: Define separate API response types
// ═══════════════════════════════════════════════════════════════

// types/api-responses.ts
// These match what the API actually returns (after Prisma transformations)

export interface EmployeeResponse {
  id: string;
  name: string;
  email: string;
  phone: string | null;
  createdAt: string;  // ISO string
  updatedAt: string;  // ISO string
  profile: {
    employmentType: 'HOURLY' | 'SALARIED';
    hourlyRate: number | null;    // Converted from Decimal
    annualSalary: number | null;  // Converted from Decimal
  } | null;
}

// Use in components
function EmployeeDetail({ employee }: { employee: EmployeeResponse }) {
  // Types are accurate!
}
```

**Frontend Prisma Type Checklist:**
- [ ] Use `| null` not `| undefined` for optional fields from API
- [ ] Expect `number` not `Decimal` for currency fields (API converts)
- [ ] Expect `string` not `Date` for datetime fields (JSON serialization)
- [ ] Create separate API response types that match actual JSON
- [ ] Use `??` (nullish coalescing) for null fallbacks in JSX

### 1. STRICT TYPE SAFETY (CRITICAL)

**NEVER use `any` or allow `undefined` without explicit handling.**

```typescript
// ❌ FORBIDDEN - Never use any
const data: any = response.json();
function handleEvent(e: any) { ... }
const items = [] as any[];

// ❌ FORBIDDEN - Never use implicit undefined
let user;                           // implicit undefined
const name = user.name;             // potential undefined access

// ✅ CORRECT - Explicit types
const data: CreateSongResponse = await response.json();
function handleEvent(e: React.MouseEvent<HTMLButtonElement>) { ... }
const items: Song[] = [];

// ✅ CORRECT - Explicit undefined handling
let user: User | null = null;       // explicit null
const name = user?.name ?? 'Unknown';  // safe access with fallback
if (song.artist) {                  // type guard
  console.log(song.artist.name);
}
```

**Type Safety Checklist:**
- [ ] No `any` types anywhere in code
- [ ] All variables have explicit types
- [ ] Optional chaining (`?.`) for nullable properties
- [ ] Nullish coalescing (`??`) for default values
- [ ] Type guards before accessing optional properties
- [ ] Proper event handler types (`React.MouseEvent`, etc.)

### 1. Import Generated Types (MANDATORY)

```typescript
// ✅ CORRECT - Import from generated types
import type { SongCardProps } from '@/types/component-props';
import type { Song, Artist } from '@/types';

// ❌ WRONG - Never define your own interfaces
interface SongCardProps { ... }
interface Song { ... }
```

### 2. Use Object Props (MANDATORY)

```typescript
// ✅ CORRECT - Object props from design
function SongCard({ song, onPlay, onShare }: SongCardProps) {
  return (
    <div>
      <h3>{song.title}</h3>
      <p>{song.artist?.name}</p>
      <button onClick={() => onPlay?.({ songId: song.id })}>Play</button>
    </div>
  );
}

// ❌ WRONG - Flattened props
function SongCard({ id, title, artistName, onPlay }: Props) {
  return (
    <div>
      <h3>{title}</h3>
      <p>{artistName}</p>
    </div>
  );
}
```

### 3. Implement ALL Events from Design

If design specifies events, you MUST implement them:

```typescript
// design_document.yml says:
// events:
//   - name: onPlay, payload: { songId: string }
//   - name: onAddToPlaylist, payload: { songId: string }
//   - name: onShare, payload: { songId: string, platform: string }

function SongCard({ song, onPlay, onAddToPlaylist, onShare }: SongCardProps) {
  return (
    <div className="song-card">
      <div className="song-info">
        <h3>{song.title}</h3>
        <p>{song.artist?.name}</p>
      </div>
      <div className="song-actions">
        <button onClick={() => onPlay?.({ songId: song.id })}>
          Play
        </button>
        <button onClick={() => onAddToPlaylist?.({ songId: song.id })}>
          Add to Playlist
        </button>
        <button onClick={() => onShare?.({ songId: song.id, platform: 'twitter' })}>
          Share
        </button>
      </div>
    </div>
  );
}
```

### 4. Component File Structure

```
app/components/
├── songs/
│   ├── SongCard.tsx
│   ├── SongList.tsx
│   └── SongPlayer.tsx
├── artists/
│   ├── ArtistCard.tsx
│   └── ArtistList.tsx
└── shared/
    ├── Button.tsx
    └── Modal.tsx
```

## Task Execution Flow

### Step 1: Read Context
```bash
# Get active version
VERSION=$(cat .workflow/current.yml | grep active_version | cut -d: -f2 | tr -d ' ')

# Read implementation context (CRITICAL)
cat .workflow/versions/$VERSION/IMPLEMENTATION_CONTEXT.md

# Read component props
cat types/component-props.ts
```

### Step 2: Verify Types Exist

Before implementing, ensure types are generated:
```bash
# Check types exist
ls types/component-props.ts

# If missing, generate them
python3 skills/guardrail-orchestrator/scripts/generate_types.py \
  .workflow/versions/$VERSION/design/design_document.yml \
  --output-dir types
```

### Step 3: Implement Component

```typescript
// app/components/songs/SongCard.tsx
'use client';

import type { SongCardProps } from '@/types/component-props';

export function SongCard({ song, showArtist = true, onPlay, onShare }: SongCardProps) {
  return (
    <div className="rounded-lg border p-4 hover:shadow-md transition-shadow">
      <div className="flex items-center gap-4">
        {song.coverUrl && (
          <img
            src={song.coverUrl}
            alt={song.title}
            className="w-16 h-16 rounded object-cover"
          />
        )}
        <div className="flex-1">
          <h3 className="font-semibold">{song.title}</h3>
          {showArtist && song.artist && (
            <p className="text-sm text-gray-600">{song.artist.name}</p>
          )}
          {song.duration && (
            <p className="text-xs text-gray-400">
              {Math.floor(song.duration / 60)}:{(song.duration % 60).toString().padStart(2, '0')}
            </p>
          )}
        </div>
        <div className="flex gap-2">
          {onPlay && (
            <button
              onClick={() => onPlay({ songId: song.id })}
              className="p-2 rounded-full hover:bg-gray-100"
            >
              ▶️
            </button>
          )}
          {onShare && (
            <button
              onClick={() => onShare({ songId: song.id, platform: 'copy' })}
              className="p-2 rounded-full hover:bg-gray-100"
            >
              📤
            </button>
          )}
        </div>
      </div>
    </div>
  );
}
```

### Step 4: Validate Implementation
```bash
# Type check
npx tsc --noEmit

# Run validation
python3 skills/guardrail-orchestrator/scripts/workflow_manager.py validate --checklist
```

### Step 5: Update Task Status
```bash
python3 skills/guardrail-orchestrator/scripts/workflow_manager.py task task_create_<entity> review
```

## Common Patterns

### Data Fetching (Server Component)

```typescript
// app/songs/page.tsx
import type { Song } from '@/types';
import { SongList } from '@/components/songs/SongList';

async function getSongs(): Promise<Song[]> {
  const res = await fetch(`${process.env.API_URL}/api/songs`, {
    cache: 'no-store'
  });
  const data = await res.json();
  return data.songs;
}

export default async function SongsPage() {
  const songs = await getSongs();
  return <SongList songs={songs} />;
}
```

### Client-Side State

```typescript
'use client';

import { useState } from 'react';
import type { Song } from '@/types';
import type { SongCardProps } from '@/types/component-props';

export function SongList({ songs }: { songs: Song[] }) {
  const [currentSong, setCurrentSong] = useState<Song | null>(null);

  const handlePlay: SongCardProps['onPlay'] = ({ songId }) => {
    const song = songs.find(s => s.id === songId);
    if (song) setCurrentSong(song);
  };

  return (
    <div className="space-y-4">
      {songs.map(song => (
        <SongCard key={song.id} song={song} onPlay={handlePlay} />
      ))}
      {currentSong && <Player song={currentSong} />}
    </div>
  );
}
```

### API Integration

```typescript
'use client';

import { useState } from 'react';
import type { CreateSongRequest } from '@/types/api-types';
import type { Song } from '@/types';

export function CreateSongForm({ onSuccess }: { onSuccess: (song: Song) => void }) {
  const [loading, setLoading] = useState(false);

  const handleSubmit = async (e: React.FormEvent<HTMLFormElement>) => {
    e.preventDefault();
    setLoading(true);

    const formData = new FormData(e.currentTarget);
    const data: CreateSongRequest = {
      title: formData.get('title') as string,
      duration: parseInt(formData.get('duration') as string) || undefined,
    };

    const res = await fetch('/api/songs', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(data),
    });

    if (res.ok) {
      const song = await res.json();
      onSuccess(song);
    }

    setLoading(false);
  };

  return (
    <form onSubmit={handleSubmit}>
      <input name="title" required placeholder="Song title" />
      <input name="duration" type="number" placeholder="Duration (seconds)" />
      <button type="submit" disabled={loading}>
        {loading ? 'Creating...' : 'Create Song'}
      </button>
    </form>
  );
}
```

### Error Boundaries

```typescript
'use client';

import { Component, ReactNode } from 'react';

interface Props {
  children: ReactNode;
  fallback?: ReactNode;
}

interface State {
  hasError: boolean;
}

export class ErrorBoundary extends Component<Props, State> {
  state = { hasError: false };

  static getDerivedStateFromError() {
    return { hasError: true };
  }

  render() {
    if (this.state.hasError) {
      return this.props.fallback || <div>Something went wrong</div>;
    }
    return this.props.children;
  }
}
```

## Checklist Before Completion

### Type Safety (CRITICAL)
- [ ] **NO `any` types** - Run `grep -r "any" --include="*.tsx" --include="*.ts" app/`
- [ ] **NO implicit undefined** - All variables have explicit types
- [ ] Optional properties use `?.` and `??`
- [ ] Event handlers have proper React types

### Implementation
- [ ] Props imported from `@/types/component-props`
- [ ] Model types imported from `@/types`
- [ ] Object props used (not flattened)
- [ ] ALL events from design are implemented
- [ ] Event handlers call with correct payload structure

### Validation
- [ ] TypeScript compiles without errors: `npx tsc --noEmit`
- [ ] No type errors in strict mode: `npx tsc --noEmit --strict`
- [ ] Validation checklist passes

## Style Guidelines

- Use Tailwind CSS classes for styling
- Follow project's existing component patterns
- Ensure accessibility (aria labels, keyboard navigation)
- Handle loading and error states
- Make components responsive

Always run validation after implementation to ensure compliance with design.