Use AskUserQuestion with:
- Question: "Which project should I run the production audit on?"
- Options:
  1. Current directory ([show actual pwd path])
  2. Enter a different path

src/
├── app/                      # Routes and pages
│   ├── (marketing)/          # Route groups for layouts
│   │   ├── page.tsx
│   │   └── layout.tsx
│   ├── (dashboard)/
│   │   ├── page.tsx
│   │   └── layout.tsx
│   ├── api/                  # API routes
│   ├── layout.tsx            # Root layout
│   ├── error.tsx             # Error boundary
│   └── not-found.tsx         # 404 page
├── components/
│   ├── ui/                   # Primitive/atomic components
│   ├── blocks/               # Composite sections
│   └── layout/               # Layout components
├── lib/                      # Utilities and shared logic
│   ├── utils/                # Pure utility functions
│   ├── hooks/                # Custom React hooks
│   ├── context/              # React context providers
│   └── api/                  # API client/fetching layer
├── types/                    # TypeScript type definitions
├── config/                   # Configuration constants
└── styles/                   # Global styles

Pages (Route Components)
  └── Fetch data, handle routing
  └── Pass data to templates/blocks

Templates (Page-level layouts)
  └── Compose blocks into page structure
  └── No data fetching

Blocks (Section components)
  └── Self-contained sections (Hero, Features, etc.)
  └── Receive content as props

UI Components (Primitives)
  └── Button, Input, Card, etc.
  └── Purely presentational
  └── Design system atoms

// ❌ BAD: Component doing too much
export function UserDashboard() {
  const [user, setUser] = useState(null);
  const [posts, setPosts] = useState([]);
  const [comments, setComments] = useState([]);
  const [notifications, setNotifications] = useState([]);
  // ... 300 lines of mixed concerns
}

// ✅ GOOD: Separated concerns
export function UserDashboard() {
  return (
    <DashboardLayout>
      <UserProfile />
      <UserPosts />
      <UserNotifications />
    </DashboardLayout>
  );
}

# Find large components (>200 lines)
find src/components -name "*.tsx" -exec wc -l {} \; | awk '$1 > 200 {print}'

# Check for prop drilling patterns
grep -r "props\." --include="*.tsx" src/components | wc -l

Server Component (page.tsx)
  └── Fetch data from CMS/API
  └── Pass as props to children

Client Components (interactive parts only)
  └── Local UI state (useState)
  └── Form state (useFormState)
  └── NO data fetching (receive as props)

// ❌ BAD: Fetching in client component
'use client';
export function ProductList() {
  const [products, setProducts] = useState([]);
  useEffect(() => {
    fetch('/api/products').then(res => res.json()).then(setProducts);
  }, []);
  // ...
}

// ✅ GOOD: Server component fetches, client receives
// page.tsx (Server Component)
export default async function ProductsPage() {
  const products = await getProducts();
  return <ProductList products={products} />;
}

// ProductList.tsx (Client Component for interactivity)
'use client';
export function ProductList({ products }: { products: Product[] }) {
  // Only UI state here
}

┌─────────────────────────────────────────────┐
│  Presentation Layer (components/)           │
│  - React components                         │
│  - UI rendering only                        │
│  - Receives data as props                   │
└─────────────────────────────────────────────┘
                    ↑ props
┌─────────────────────────────────────────────┐
│  Application Layer (app/, lib/hooks/)       │
│  - Page components                          │
│  - Custom hooks                             │
│  - Orchestrates data flow                   │
└─────────────────────────────────────────────┘
                    ↑ data
┌─────────────────────────────────────────────┐
│  Data Layer (lib/api/, lib/content/)        │
│  - API clients                              │
│  - Data fetching functions                  │
│  - Data transformation                      │
└─────────────────────────────────────────────┘
                    ↑ raw data
┌─────────────────────────────────────────────┐
│  External Services (CMS, APIs, DB)          │
└─────────────────────────────────────────────┘

// lib/content/index.ts - Data fetching abstraction
export async function getPageContent(slug: string) { ... }
export async function getProducts() { ... }

// lib/utils/formatters.ts - Pure utility functions
export function formatPrice(amount: number) { ... }
export function formatDate(date: Date) { ... }

// lib/hooks/useCart.ts - Stateful logic
export function useCart() { ... }

// components/ui/Button.tsx - Presentational only
export function Button({ children, variant }) { ... }

// lib/api/client.ts - Base API client
class APIClient {
  private baseUrl: string;

  constructor(baseUrl: string) {
    this.baseUrl = baseUrl;
  }

  async get<T>(endpoint: string): Promise<T> {
    const response = await fetch(`${this.baseUrl}${endpoint}`);
    if (!response.ok) {
      throw new APIError(response.status, await response.text());
    }
    return response.json();
  }

  async post<T>(endpoint: string, data: unknown): Promise<T> {
    // ...
  }
}

// lib/api/products.ts - Domain-specific functions
export async function getProducts(): Promise<Product[]> {
  return apiClient.get<Product[]>('/products');
}

export async function getProduct(id: string): Promise<Product> {
  return apiClient.get<Product>(`/products/${id}`);
}

// lib/queries/index.ts - Query definitions
export const GET_PAGE_CONTENT = gql`...`;

// lib/content/index.ts - Content fetching abstraction
export async function getPageContent(slug: string) {
  const client = getServerClient();
  const { data } = await client.query({
    query: GET_PAGE_CONTENT,
    variables: { slug },
  });
  return data?.page ?? null;
}

// types/index.ts - Re-export all types
export * from './api';
export * from './content';
export * from './components';

// types/api.ts - API response types
export interface APIResponse<T> {
  data: T;
  meta: {
    total: number;
    page: number;
  };
}

export interface APIError {
  code: string;
  message: string;
}

// types/content.ts - CMS content types
export interface Page {
  id: string;
  slug: string;
  title: string;
  content: PageContent;
}

export interface PageContent {
  hero: HeroSection;
  sections: Section[];
}

// types/components.ts - Shared component types
export interface BaseComponentProps {
  className?: string;
  children?: React.ReactNode;
}

// ✅ GOOD: Infer from schema/API
type Product = Awaited<ReturnType<typeof getProduct>>;

// ✅ GOOD: Discriminated unions for state
type AsyncState<T> =
  | { status: 'idle' }
  | { status: 'loading' }
  | { status: 'success'; data: T }
  | { status: 'error'; error: Error };

// ✅ GOOD: Zod for runtime validation + type inference
const ProductSchema = z.object({
  id: z.string(),
  name: z.string(),
  price: z.number(),
});
type Product = z.infer<typeof ProductSchema>;

// ❌ BAD: Hard-coded dependency
export async function getProducts() {
  const response = await fetch('https://api.example.com/products');
  return response.json();
}

// ✅ GOOD: Injectable dependency
export function createProductService(apiClient: APIClient) {
  return {
    async getProducts() {
      return apiClient.get<Product[]>('/products');
    },
    async getProduct(id: string) {
      return apiClient.get<Product>(`/products/${id}`);
    },
  };
}

// Usage
const productService = createProductService(apiClient);

// Testing
const mockClient = { get: jest.fn() };
const testService = createProductService(mockClient);

// ✅ Dynamic import for heavy components
const HeavyChart = dynamic(() => import('./HeavyChart'), {
  loading: () => <ChartSkeleton />,
  ssr: false, // If client-only
});

// ✅ Route groups for different layouts
app/
├── (marketing)/     # Marketing pages layout
│   ├── layout.tsx
│   └── page.tsx
├── (app)/           # App dashboard layout
│   ├── layout.tsx
│   └── dashboard/
└── (auth)/          # Auth layout
    ├── layout.tsx
    └── login/

// ✅ Parallel routes for complex UIs
app/
├── @modal/          # Modal slot
├── @sidebar/        # Sidebar slot
└── layout.tsx       # Composes slots

// Usage
<Accordion>
  <Accordion.Item>
    <Accordion.Trigger>Title</Accordion.Trigger>
    <Accordion.Content>Content</Accordion.Content>
  </Accordion.Item>
</Accordion>

<DataFetcher url="/api/users">
  {({ data, loading, error }) => (
    loading ? <Spinner /> : <UserList users={data} />
  )}
</DataFetcher>

function useDebounce<T>(value: T, delay: number): T {
  const [debouncedValue, setDebouncedValue] = useState(value);
  useEffect(() => {
    const handler = setTimeout(() => setDebouncedValue(value), delay);
    return () => clearTimeout(handler);
  }, [value, delay]);
  return debouncedValue;
}

.env*
.gitignore
src/**/*.ts
src/**/*.tsx
next.config.js

# Check for hardcoded secrets patterns
grep -r "sk_live\|sk_test\|api_key\|apikey\|secret\|password\|token" --include="*.ts" --include="*.tsx" --include="*.js" src/

# Check if .env files are gitignored
grep -E "^\.env" .gitignore

# List all NEXT_PUBLIC variables
grep -r "NEXT_PUBLIC_" --include="*.ts" --include="*.tsx" src/

src/app/**/page.tsx
src/middleware.ts
src/lib/auth/

next.config.js
vercel.json
middleware.ts

const securityHeaders = [
  { key: 'Strict-Transport-Security', value: 'max-age=31536000; includeSubDomains' },
  { key: 'X-Content-Type-Options', value: 'nosniff' },
  { key: 'X-Frame-Options', value: 'DENY' },
  { key: 'X-XSS-Protection', value: '1; mode=block' },
  { key: 'Referrer-Policy', value: 'strict-origin-when-cross-origin' },
];

module.exports = {
  async headers() {
    return [{ source: '/(.*)', headers: securityHeaders }];
  },
};

# Check for console.log statements
grep -r "console\." --include="*.ts" --include="*.tsx" src/

# Check source map configuration
grep -r "productionBrowserSourceMaps" next.config.js

# Analyze bundle
npm run build
npx @next/bundle-analyzer

# Check bundle size
ls -la .next/static/chunks/

src/components/**/*.tsx
src/app/**/*.tsx
next.config.js (images.remotePatterns)

src/app/**/page.tsx
src/lib/content/
src/lib/queries/

# Run Lighthouse
npx lighthouse http://localhost:3000 --output=json --output-path=./lighthouse-report.json

# Or use Chrome DevTools Lighthouse tab

tsconfig.json
src/**/*.ts
src/**/*.tsx

# Check for any types
grep -r ": any" --include="*.ts" --include="*.tsx" src/

# Check for ts-ignore
grep -r "@ts-ignore\|@ts-nocheck" --include="*.ts" --include="*.tsx" src/

# Run type check
npx tsc --noEmit

{
  "compilerOptions": {
    "strict": true,
    "noImplicitAny": true,
    "strictNullChecks": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true
  }
}

# Run linting
npm run lint

# Check for ESLint config
cat .eslintrc.json || cat .eslintrc.js || cat eslint.config.js

src/modules/
├── user/
│   ├── index.ts                 # Barrel export
│   ├── user.module.ts           # Module definition
│   ├── entities/
│   │   └── user.entity.ts
│   ├── dto/
│   │   ├── create-user.dto.ts
│   │   └── update-user.dto.ts
│   ├── services/
│   │   └── user.service.ts
│   ├── resolvers/               # or controllers/
│   │   └── user.resolver.ts
│   └── __tests__/               # or *.spec.ts colocated
│       └── user.service.spec.ts
├── auth/                        # Same structure
├── content/                     # Same structure
└── media/                       # Same structure

❌ Inconsistent structure across modules:
modules/
├── user/
│   ├── user.service.ts          # Flat structure
│   ├── user.controller.ts
│   └── user.entity.ts
├── auth/
│   ├── services/                # Nested structure
│   │   └── auth.service.ts
│   ├── controllers/
│   │   └── auth.controller.ts
│   └── entities/
│       └── auth.entity.ts

❌ Missing index.ts in some modules but not others
❌ Some modules use singular names (user/) others plural (users/)

# Compare module structures
for dir in src/modules/*/; do echo "=== $dir ===" && ls -la "$dir"; done

# Find modules missing index.ts
find src/modules -maxdepth 2 -type d ! -exec test -e '{}/index.ts' \; -print

# Check for inconsistent nesting
find src/modules -type f -name "*.service.ts" | head -10
find src/modules -type f -name "*.entity.ts" | head -10

// ❌ Inconsistent file naming
user-profile.service.ts    // kebab-case
UserProfile.entity.ts      // PascalCase
userProfile.dto.ts         // camelCase

// ❌ Inconsistent class suffixes
class UserService {}       // "Service"
class AuthSvc {}           // "Svc"
class ContentManager {}    // "Manager"

// ❌ Mixed conventions in same entity
@Entity('UserProfiles')    // PascalCase table
class UserProfile {
  @Column()
  firstName: string;       // camelCase property

  @Column({ name: 'last_name' })
  lastName: string;        // snake_case in DB, camelCase in code (OK)

  @Column()
  created_at: Date;        // snake_case property (inconsistent!)
}

# Check for mixed file naming patterns
find src -name "*.ts" | xargs -I {} basename {} | sort | uniq -c | sort -rn

# Find files not following kebab-case
find src -name "*.ts" | grep -E "[A-Z]" | grep -v node_modules

# Check for inconsistent class suffixes
grep -r "class.*Service\|class.*Svc\|class.*Manager" --include="*.ts" src/

// 1. Node built-ins
import { readFile } from 'fs';

// 2. External packages (npm)
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';

// 3. Internal aliases (@/ paths)
import { DatabaseService } from '@/database';
import { BaseEntity } from '@/common';

// 4. Relative imports (parent first, then siblings)
import { UserEntity } from '../entities';
import { CreateUserDto } from './dto';

// ❌ Deep relative imports (use barrel exports or aliases)
import { UserEntity } from '../../../modules/user/entities/user.entity';

// ❌ Importing from index when you could import directly (in same module)
import { UserService } from './index';  // Should be './user.service'

// ❌ Inconsistent export style within project
// file1.ts: export default class Foo {}
// file2.ts: export class Bar {}

// ❌ Circular dependency
// user.service.ts imports auth.service.ts
// auth.service.ts imports user.service.ts

# Find potential circular dependencies
npx madge --circular src/

# Check for deep relative imports
grep -r "from '\.\./\.\./\.\." --include="*.ts" src/

# Find default exports (should use named exports for consistency)
grep -r "export default" --include="*.ts" src/

// Consistent custom exception hierarchy
// src/common/exceptions/
export class BaseException extends Error {
  constructor(
    public readonly code: string,
    message: string,
    public readonly statusCode: number = 500,
  ) {
    super(message);
  }
}

export class NotFoundException extends BaseException {
  constructor(resource: string, identifier: string) {
    super('NOT_FOUND', `${resource} with id '${identifier}' not found`, 404);
  }
}

export class ValidationException extends BaseException {
  constructor(message: string, public readonly errors: ValidationError[]) {
    super('VALIDATION_ERROR', message, 400);
  }
}

// Consistent usage across services
throw new NotFoundException('User', userId);
throw new ValidationException('Invalid input', errors);

// ❌ Inconsistent exception throwing
// Service A:
throw new Error('User not found');

// Service B:
throw new NotFoundException('User not found');

// Service C:
throw new HttpException('User not found', 404);

// ❌ Inconsistent error message formats
throw new Error('user not found');           // lowercase
throw new Error('User Not Found');           // Title Case
throw new Error('USER_NOT_FOUND');           // SCREAMING
throw new Error('User with ID 123 not found'); // with ID
throw new Error('Cannot find user');         // different phrasing

# Find all throw statements to check consistency
grep -r "throw new" --include="*.ts" src/ | head -30

# Check for generic Error usage (should use custom exceptions)
grep -r "throw new Error(" --include="*.ts" src/

# Find HttpException usage (check for consistency)
grep -r "HttpException\|NotFoundException\|BadRequestException" --include="*.ts" src/

// Shared types in types/ or common/
// src/common/types/
export interface PaginationParams {
  page: number;
  limit: number;
}

export interface PaginatedResponse<T> {
  items: T[];
  total: number;
  page: number;
  totalPages: number;
}

// Module-specific types colocated
// src/modules/user/types/
export interface UserFilters {
  status?: UserStatus;
  role?: UserRole;
}

// Consistent DTO pattern
export class CreateUserDto {
  @IsString()
  @IsNotEmpty()
  name: string;

  @IsEmail()
  email: string;

  @IsOptional()
  @IsString()
  bio?: string;
}

// ❌ Inconsistent interface vs type usage
interface User { ... }    // Some use interface
type Product = { ... }    // Others use type alias

// ❌ Inconsistent optional handling
interface Config {
  apiKey?: string;        // Optional with ?
  timeout: number | undefined;  // Optional with | undefined
  retries: number | null;       // Nullable (different meaning!)
}

// ❌ DTOs without validation in some modules
// user.dto.ts - has validation decorators
// product.dto.ts - no validation decorators

# Check for interface vs type consistency
grep -r "^interface\|^export interface" --include="*.ts" src/ | wc -l
grep -r "^type\|^export type" --include="*.ts" src/ | wc -l

# Find DTOs without class-validator decorators
find src -name "*.dto.ts" -exec grep -L "@Is\|@Min\|@Max\|@Valid" {} \;

# Check for mixed null/undefined
grep -r "| null\|| undefined" --include="*.ts" src/ | head -20

@Injectable()
export class UserService {
  constructor(
    @InjectRepository(User)
    private readonly userRepository: Repository<User>,
    private readonly eventEmitter: EventEmitter,  // Injected, not instantiated
  ) {}

  // Consistent CRUD naming
  async create(dto: CreateUserDto): Promise<User> { ... }
  async findAll(filters: UserFilters): Promise<User[]> { ... }
  async findOne(id: string): Promise<User> { ... }
  async findOneOrFail(id: string): Promise<User> { ... }  // Throws if not found
  async update(id: string, dto: UpdateUserDto): Promise<User> { ... }
  async remove(id: string): Promise<void> { ... }

  // Consistent parameter order: identifier first, then data
  async updateStatus(id: string, status: UserStatus): Promise<User> { ... }
}

// ❌ Inconsistent CRUD naming across services
// UserService:
async create() {}
async getAll() {}
async getById() {}

// ProductService:
async createProduct() {}
async findAll() {}
async findOne() {}

// OrderService:
async add() {}
async list() {}
async fetch() {}

// ❌ Inconsistent return types
async findUser(id): Promise<User> {}      // Returns entity
async findProduct(id): Promise<ProductDto> {}  // Returns DTO

// ❌ Instantiating dependencies instead of injection
class UserService {
  private logger = new Logger();  // ❌ Should be injected
}

# Compare method names across services
grep -r "async create\|async find\|async get\|async update\|async delete\|async remove" --include="*.service.ts" src/

# Check for new keyword in services (potential DI violation)
grep -r "new.*(" --include="*.service.ts" src/ | grep -v "new Date\|new Error\|new Map\|new Set"

// Consistent test file naming: *.spec.ts (unit) or *.e2e-spec.ts (e2e)
// Colocated: user.service.spec.ts next to user.service.ts
// Or centralized: __tests__/user.service.spec.ts

describe('UserService', () => {
  let service: UserService;
  let repository: MockType<Repository<User>>;

  // Consistent setup
  beforeEach(async () => {
    const module = await Test.createTestingModule({
      providers: [
        UserService,
        {
          provide: getRepositoryToken(User),
          useFactory: repositoryMockFactory,
        },
      ],
    }).compile();

    service = module.get(UserService);
    repository = module.get(getRepositoryToken(User));
  });

  // Consistent describe structure
  describe('create', () => {
    it('should create a user with valid data', async () => { ... });
    it('should throw ValidationException for invalid email', async () => { ... });
  });

  describe('findOne', () => {
    it('should return user when found', async () => { ... });
    it('should throw NotFoundException when not found', async () => { ... });
  });
});

// ❌ Inconsistent test descriptions
it('creates user')           // No "should"
it('should create a user')   // With "should"
it('user creation works')    // Different style

// ❌ Inconsistent mocking
// Test A: Uses jest.mock()
// Test B: Uses manual mock objects
// Test C: Uses @nestjs/testing mock factories

// ❌ Missing tests for some modules
// user.service.spec.ts ✓
// product.service.spec.ts ✓
// order.service.spec.ts ✗ (missing!)

# Find modules missing tests
for service in $(find src -name "*.service.ts" | grep -v spec); do
  spec="${service%.ts}.spec.ts"
  [ ! -f "$spec" ] && echo "Missing: $spec"
done

# Check test description consistency
grep -r "it('" --include="*.spec.ts" src/ | head -20

/**
 * Service for managing user accounts and authentication.
 *
 * @remarks
 * All methods require the caller to have appropriate permissions.
 * User data is automatically scoped to the current tenant.
 */
@Injectable()
export class UserService {
  /**
   * Creates a new user account.
   *
   * @param dto - The user creation data
   * @returns The created user entity
   * @throws {ValidationException} When email is already taken
   * @throws {ForbiddenException} When caller lacks permission
   */
  async create(dto: CreateUserDto): Promise<User> { ... }
}

// ❌ Obvious comments that don't add value
// Increment the counter
counter++;

// ❌ Outdated comments
// TODO: Implement validation (but validation exists)
// Returns user by ID (but method returns Promise<User[]>)

// ❌ Stale TODOs with no tracking
// TODO: Fix this later
// FIXME: Temporary hack
// HACK: Need to refactor

# Find TODOs and FIXMEs
grep -rn "TODO\|FIXME\|HACK\|XXX" --include="*.ts" src/

# Check JSDoc coverage on services
grep -l "@Injectable" src/**/*.service.ts | while read f; do
  grep -q "/\*\*" "$f" && echo "✓ $f" || echo "✗ $f"
done

// ❌ Pagination logic repeated
// user.service.ts
const skip = (page - 1) * limit;
const [items, total] = await this.repo.findAndCount({ skip, take: limit });
return { items, total, page, totalPages: Math.ceil(total / limit) };

// product.service.ts - same code!
const skip = (page - 1) * limit;
const [items, total] = await this.repo.findAndCount({ skip, take: limit });
return { items, total, page, totalPages: Math.ceil(total / limit) };

// ✅ Extract to shared utility
// common/utils/pagination.ts
export function paginate<T>(items: T[], total: number, page: number, limit: number) {
  return { items, total, page, totalPages: Math.ceil(total / limit) };
}

# Find similar code blocks (using jscpd)
npx jscpd src/ --min-lines 5 --min-tokens 50

# Find duplicate string patterns
grep -roh "throw new.*Exception" --include="*.ts" src/ | sort | uniq -c | sort -rn

# Find similar method signatures
grep -r "async find.*(" --include="*.service.ts" src/

src/app/error.tsx        # Global error boundary
src/app/not-found.tsx    # 404 page
src/app/global-error.tsx # Root layout errors

'use client';

export default function Error({
  error,
  reset,
}: {
  error: Error & { digest?: string };
  reset: () => void;
}) {
  return (
    <div>
      <h2>Something went wrong!</h2>
      <button onClick={() => reset()}>Try again</button>
    </div>
  );
}

src/app/api/**/route.ts
src/lib/content/
src/lib/queries/

# Check for div with onClick (should be button)
grep -r "div.*onClick\|span.*onClick" --include="*.tsx" src/

# Check heading usage
grep -r "<h[1-6]" --include="*.tsx" src/

# Check for images without alt
grep -r "<Image\|<img" --include="*.tsx" src/ | grep -v "alt="

# Check for inputs without labels
grep -r "<input\|<Input" --include="*.tsx" src/

src/app/layout.tsx
src/app/**/page.tsx
src/app/**/layout.tsx

// src/app/layout.tsx
export const metadata: Metadata = {
  title: {
    default: 'Site Name',
    template: '%s | Site Name',
  },
  description: 'Site description',
  openGraph: {
    title: 'Site Name',
    description: 'Site description',
    url: 'https://example.com',
    siteName: 'Site Name',
    type: 'website',
  },
  twitter: {
    card: 'summary_large_image',
  },
};

public/robots.txt
app/sitemap.ts (or sitemap.xml)

.env.example          # Template with placeholder values
.env.local           # Local development (gitignored)
.env.production      # Production overrides (if needed)

// src/lib/env.ts
import { z } from 'zod';

const envSchema = z.object({
  NEXT_PUBLIC_CMS_GRAPHQL_URL: z.string().url(),
  CMS_ORGANIZATION_ID: z.string().uuid(),
  NODE_ENV: z.enum(['development', 'production', 'test']),
});

export const env = envSchema.parse(process.env);

next.config.js
next.config.mjs

# Check for vulnerabilities
npm audit

# Check for outdated packages
npm outdated

# Update to latest (be careful)
npm update

# Find unused dependencies
npx depcheck

# Verify lock file is in sync
npm ci

# Check licenses
npx license-checker --summary

# Run production build
npm run build

# Check build output
ls -la .next/

vercel.json
.vercelignore

# Check for Sentry
grep -r "sentry" package.json
grep -r "@sentry" src/

# Production Readiness Audit Report

**Project:** [PROJECT_NAME]
**Date:** [DATE]
**Auditor:** Claude Code

## Summary

| Category | Critical | High | Medium | Low | Pass |
|----------|----------|------|--------|-----|------|
| Architecture | X | X | X | X | ✓/✗ |
| Security | X | X | X | X | ✓/✗ |
| Performance | X | X | X | X | ✓/✗ |
| Code Quality | X | X | X | X | ✓/✗ |
| **DX & Consistency** | X | X | X | X | ✓/✗ |
| Error Handling | X | X | X | X | ✓/✗ |
| Accessibility | X | X | X | X | ✓/✗ |
| SEO | X | X | X | X | ✓/✗ |
| Configuration | X | X | X | X | ✓/✗ |
| Dependencies | X | X | X | X | ✓/✗ |
| Build/Deploy | X | X | X | X | ✓/✗ |
| Monitoring | X | X | X | X | ✓/✗ |

**Overall Status:** [READY / NOT READY / CONDITIONAL]

## Critical Issues (Must Fix)

1. [Issue description]
   - **Location:** [file:line]
   - **Fix:** [recommended fix]

## High Priority Issues

1. [Issue description]
   - **Location:** [file:line]
   - **Fix:** [recommended fix]

## Medium Priority Issues

[List issues]

## Low Priority Issues

[List issues]

## Recommendations

[Additional recommendations for improvement]