ai-developer-skill-os 1.7.1 → 1.9.1

package/skills/_archive_old_skills/qk-help/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: qk-help
+description: >-
+  Tra cứu danh sách toàn bộ kỹ năng (skills) hiện có và đọc các mẹo (pro-tips) kết hợp kỹ năng để tăng tốc độ code.
+version: 1.0.0
+category: engineering
+tags: [help, list, tips, guide, manual]
+platforms: [antigravity, claude-code, kilo-code, cursor, windsurf]
+---
+
+# 📚 Cẩm nang AI Developer Skill OS
+
+> **Nhiệm vụ của bạn (AI):** Khi người dùng gọi lệnh `./qk-help`, hãy xuất ra màn hình (bằng tiếng Việt) danh sách các kỹ năng phân theo nhóm và các Mẹo sử dụng (Pro-tips) dưới đây một cách sinh động, dễ đọc (dùng markdown, in đậm, emoji). Không cần phân tích code, chỉ đóng vai trò là "Sách hướng dẫn sử dụng".
+
+---
+
+## 🎯 1. Danh sách Kỹ năng (Skills Directory)
+
+Dưới đây là các kỹ năng chính bạn có thể gọi bằng cách gõ `./qk-[tên-kỹ-năng]`:
+
+### 🎨 Frontend (Giao diện)
+- **`qk-ui-builder`**: Xây dựng UI, Layout, Component, Modal phức tạp.
+- **`qk-table-crud-generator`**: Chuyên vẽ bảng danh sách (Table), phân trang, lọc và form Thêm/Sửa/Xóa.
+- **`qk-form-builder`**: Chuyên làm Form nhập liệu, validate (Zod/Yup).
+- **`qk-component-generator`**: Tạo Component độc lập, tái sử dụng (Button, Input, Card).
+- **`qk-state-management`**: Xử lý Redux, Zustand, React Query.
+- **`qk-frontend-debug`**: Bắt bệnh vỡ layout, infinite re-render, lỗi Hydration.
+- **`qk-frontend-performance`**: Tối ưu tốc độ, chống re-render thừa.
+- **`qk-frontend-architecture`**: Tư vấn kiến trúc thư mục Frontend.
+- **`qk-frontend-testing`**: Viết Unit Test / E2E Test cho Frontend.
+- **`qk-accessibility-audit`**: Sửa lỗi a11y, hỗ trợ Screen reader.
+
+### ⚙️ Engineering & Integration (Tích hợp)
+- **`qk-api-integration`**: [Cực mạnh] Bóc tách tài liệu API (Curl, Postman) -> Gen Type, Service, Hook -> (Tùy chọn) Ốp thẳng vào UI.
+- **`qk-refactor`**: Tối ưu, dọn dẹp mã nguồn sạch sẽ.
+- **`qk-bug-fix`**: Chẩn đoán lỗi sâu và sửa an toàn.
+- **`qk-project-audit`**: Quét toàn bộ dự án tìm nợ kỹ thuật.
+- **`qk-git-engineer`**: Viết Commit / PR chuẩn Conventional.
+- **`qk-migration`**: Nâng cấp version framework / thư viện.
+- **`qk-agent-orchestrator`**: Kiến trúc sư, lên plan phân rã task lớn.
+- **`qk-context-manager`**: Tóm tắt kiến trúc dự án.
+
+### 🗄️ Backend (Máy chủ)
+- **`qk-database-engineer`**: Thiết kế Schema, ORM (Prisma/Drizzle), Migration.
+- **`qk-backend-architecture`**: Setup kiến trúc Backend (Node/Nest/Python).
+- **`qk-auth-security`**: Phân quyền RBAC, JWT, OAuth.
+- **`qk-deployment`**: Viết Dockerfile, CI/CD Pipeline.
+
+---
+
+## 💡 2. Mẹo sử dụng Nâng cao (Pro-Tips)
+
+### Mẹo 1: Kết hợp Kỹ năng (Skill Chaining) 🔗
+Đừng bắt AI làm từ A-Z bằng 1 câu prompt. Hãy gọi liên hoàn:
+> *"Hãy dùng `./qk-api-integration` để bóc tách API này thành hook React Query. Sau đó dùng `./qk-table-crud-generator` vẽ cái Bảng hiển thị danh sách tích hợp hook đó."*
+
+### Mẹo 2: Chế độ "Một phát ăn ngay" (End-to-End) 🚀
+Nếu bạn đã có sẵn 1 màn hình UI (chỉ thiếu data), hãy ép `qk-api-integration` làm End-to-End:
+> *"./qk-api-integration Dưới đây là API Get Profile. Hãy khai báo Type, viết Hook và TÍCH HỢP THẲNG LUÔN vào file \`Profile.tsx\` đang mở."*
+
+### Mẹo 3: Truyền tham số ép buộc (Arguments) 🎯
+Bạn có thể ép AI dùng công nghệ bạn muốn bằng cách thêm \`--tham_số\`:
+> *"./qk-ui-builder --fw=react --css=tailwind Hãy vẽ màn hình Đăng nhập."*
+
+### Mẹo 4: Nhờ "Kiến trúc sư" phân việc 🧠
+Nếu bạn có một tính năng quá lớn (ví dụ: Làm tính năng Giỏ Hàng), đừng tự chia việc, hãy gọi:
+> *"./qk-agent-orchestrator Tôi muốn làm tính năng Giỏ hàng. Hãy phân tích và lên kế hoạch gọi các skill \`qk-\` nào cho phù hợp."*

package/skills/{qk-state-management → _archive_old_skills/qk-state-management}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: qk-state-management
+name: qk-state-management
 description: >-
   Xác định và triển khai chiến lược quản lý state phù hợp (Zustand, Redux, React Query, Local State).
 version: 1.0.0

package/skills/{qk-table-crud-generator → _archive_old_skills/qk-table-crud-generator}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: qk-table-crud-generator
+name: qk-table-crud-generator
 description: >-
   Tạo các bảng dữ liệu admin với đầy đủ tính năng phân trang, sắp xếp, lọc và thao tác thêm/sửa/xóa (CRUD).
 version: 1.0.0

package/skills/qk-access-policy/SKILL.md

@@ -0,0 +1,127 @@
+---
+name: qk-access-policy
+purpose: Quản lý chính sách bảo mật, phân quyền RBAC và ranh giới truy cập.
+mode_supported: [enterprise]
+input: [Access rules]
+output: [Access policies]
+workflow: [1. Rà soát Roles -> 2. Kiểm tra Permissions -> 3. Cập nhật rule]
+allowed_tools: [read_file, write_to_file]
+handoff_to: [qk-engineering-standard]
+---
+
+# 🛠️ qk-access-policy - Quy Trình Vận Hành Chuẩn (SOP)
+
+> **Mô tả:** Quản lý chính sách bảo mật, phân quyền RBAC và ranh giới truy cập.
+
+## 🎯 1. Mục Tiêu (Goal)
+- Hoàn thành thành công tác vụ được giao liên quan đến nhiệm vụ của skill.
+- Đảm bảo chất lượng mã nguồn và tính nhất quán của hệ thống.
+
+## 🔄 2. Chuỗi Hành Động (Chain of Thought / SOP)
+*(Bắt buộc AI phải suy nghĩ và làm theo đúng thứ tự)*
+1. **Phân tích (Analyze):** Thu thập ngữ cảnh và hiểu rõ yêu cầu đầu vào.
+2. **Lên kế hoạch (Plan):** Xác định các bước cần thay đổi/tạo mới dựa trên bộ luật (rules).
+3. **Thực thi (Execute):** Tiến hành sửa đổi mã nguồn hoặc tạo tài liệu.
+4. **Xác thực (Verify):** Đảm bảo đầu ra đáp ứng đúng yêu cầu và không vi phạm quy định.
+
+## 🛡️ 3. Ràng Buộc & Quy Tắc (Constraints)
+- CẤM bỏ qua việc kiểm tra `qk-engineering-standard` trước khi viết code.
+- Mọi quyết định kỹ thuật phải dựa trên nội dung tại phần Deep Knowledge (nếu có).
+
+## 🤝 4. Giao Thức Bàn Giao (Handoff Protocol)
+- Đích đến: `qk-engineering-standard`
+- Nội dung bàn giao: Chuyển toàn bộ ngữ cảnh và kết quả đã thực thi cho bước tiếp theo.
+
+## 📚 5. Kiến Thức Chuyên Sâu (Deep Knowledge)
+
+*(Nền tảng kiến thức và quy tắc chi tiết kế thừa từ kỹ sư)*
+
+---
+
+
+
+# Auth & Security Engineer
+
+> **Language rule:**
+> Use English for: code, identifiers, file names, architecture terms, technical decisions.
+> Use the user's language for: explanations, questions, summaries, and feedback.
+> The user may write in any language — detect and match it automatically.
+
+---
+
+## Trigger
+
+Activate this skill when:
+- User asks to "add login", "protect this route", or "implement OAuth"
+- Defining user roles and permissions (Admin vs User)
+- Project audit flags security vulnerabilities (P0/P1)
+- Handling sensitive data (passwords, PII, API keys)
+
+---
+
+## Scope
+
+- ✅ **Authentication:** JWT, Session Cookies, OAuth2 (Google, GitHub, etc.), Magic Links.
+- ✅ **Authorization:** Role-Based Access Control (RBAC), Middleware guards.
+- ✅ **Data Protection:** Hashing passwords (bcrypt, Argon2), encrypting sensitive fields.
+- ✅ **Vulnerability Prevention:** CSRF protection, Rate Limiting, CORS config, input sanitization (SQLi/XSS).
+
+---
+
+## Non-goals
+
+- ❌ Do NOT store passwords in plain text. Ever.
+- ❌ Do NOT hardcode secrets or private keys in the code (use `.env`).
+- ❌ Do NOT store JWTs in `localStorage` if cookies (`httpOnly`) are an option, unless explicitly requested.
+
+---
+
+## Workflow
+
+### Phase 1 — Strategy Selection
+
+Determine the auth mechanism:
+1. **Stateless (JWT):** Good for mobile/SPAs, distributed systems.
+2. **Stateful (Sessions):** Good for traditional web apps, easier revocation.
+3. **Third-party (OAuth / Auth0 / NextAuth / Supabase):** Offload auth complexity.
+
+### Phase 2 — Implementation
+
+**For JWT + Cookies (Recommended Web Pattern):**
+1. Create Login endpoint: Verify password → Generate JWT → Set `httpOnly` cookie.
+2. Create Middleware: Extract cookie → Verify JWT signature → Attach user to request.
+3. Create Logout endpoint: Clear the cookie.
+
+**For Authorization:**
+1. Define roles (e.g., `enum Role { ADMIN, USER }`).
+2. Create Role Middleware: Check `req.user.role`.
+
+### Phase 3 — Security Audit
+
+Verify:
+- Passwords are hashed with a salt (e.g., `bcrypt.hash(password, 10)`).
+- Cookies are `httpOnly`, `Secure` (in prod), and `SameSite`.
+- CORS is configured to only allow trusted origins.
+
+---
+
+## Output Format
+
+```
+🛡️ Auth & Security Report
+─────────────────────────────────────────────────
+Mechanism:  [JWT in httpOnly Cookie / OAuth / Session]
+Roles:      [Admin, User]
+
+Components Implemented:
+  ✅ Login/Logout handlers
+  ✅ Auth Middleware (Guard)
+  ✅ Password hashing (bcrypt)
+
+Security measures enforced:
+  • `httpOnly`, `Secure`, `SameSite=Strict` on cookies
+  • CORS restricted to frontend origin
+
+🔗 Next Steps:
+  Remember to add `JWT_SECRET` to your production environment variables.
+```

package/skills/qk-ai-builder/SKILL.md

@@ -0,0 +1,33 @@
+---
+name: qk-ai-builder
+purpose: Thiết kế hệ thống AI App (RAG, Agent, Prompt, Logic AI).
+mode_supported: [enterprise]
+input: [AI Requirement]
+output: [AI Architecture, Agents]
+workflow: [1. Architecture -> 2. Agent -> 3. Memory -> 4. Evaluation -> 5. Monitoring]
+allowed_tools: [write_to_file]
+handoff_to: [qk-validation-gate]
+---
+
+# 🛠️ qk-ai-builder - Quy Trình Vận Hành Chuẩn (SOP)
+
+> **Mô tả:** Thiết kế hệ thống AI App (RAG, Agent, Prompt, Logic AI).
+
+## 🎯 1. Mục Tiêu (Goal)
+- Hoàn thành thành công tác vụ được giao liên quan đến nhiệm vụ của skill.
+- Đảm bảo chất lượng mã nguồn và tính nhất quán của hệ thống.
+
+## 🔄 2. Chuỗi Hành Động (Chain of Thought / SOP)
+*(Bắt buộc AI phải suy nghĩ và làm theo đúng thứ tự)*
+1. **Phân tích (Analyze):** Thu thập ngữ cảnh và hiểu rõ yêu cầu đầu vào.
+2. **Lên kế hoạch (Plan):** Xác định các bước cần thay đổi/tạo mới dựa trên bộ luật (rules).
+3. **Thực thi (Execute):** Tiến hành sửa đổi mã nguồn hoặc tạo tài liệu.
+4. **Xác thực (Verify):** Đảm bảo đầu ra đáp ứng đúng yêu cầu và không vi phạm quy định.
+
+## 🛡️ 3. Ràng Buộc & Quy Tắc (Constraints)
+- CẤM bỏ qua việc kiểm tra `qk-engineering-standard` trước khi viết code.
+- Mọi quyết định kỹ thuật phải dựa trên nội dung tại phần Deep Knowledge (nếu có).
+
+## 🤝 4. Giao Thức Bàn Giao (Handoff Protocol)
+- Đích đến: `qk-validation-gate`
+- Nội dung bàn giao: Chuyển toàn bộ ngữ cảnh và kết quả đã thực thi cho bước tiếp theo.

package/skills/qk-api-lifecycle/SKILL.md

@@ -0,0 +1,420 @@
+---
+name: qk-api-lifecycle
+purpose: Thiết kế Spec, Code Service, Types, Test, Docs cho API.
+mode_supported: [standard]
+input: [API requirement]
+output: [API Service, Routes, Docs]
+workflow: [1. Spec -> 2. Type -> 3. Service -> 4. Test -> 5. Docs]
+allowed_tools: [write_to_file, run_command]
+handoff_to: [qk-validation-gate]
+---
+
+# 🛠️ qk-api-lifecycle - Quy Trình Vận Hành Chuẩn (SOP)
+
+> **Mô tả:** Thiết kế Spec, Code Service, Types, Test, Docs cho API.
+
+## 🎯 1. Mục Tiêu (Goal)
+- Hoàn thành thành công tác vụ được giao liên quan đến nhiệm vụ của skill.
+- Đảm bảo chất lượng mã nguồn và tính nhất quán của hệ thống.
+
+## 🔄 2. Chuỗi Hành Động (Chain of Thought / SOP)
+*(Bắt buộc AI phải suy nghĩ và làm theo đúng thứ tự)*
+1. **Phân tích (Analyze):** Thu thập ngữ cảnh và hiểu rõ yêu cầu đầu vào.
+2. **Lên kế hoạch (Plan):** Xác định các bước cần thay đổi/tạo mới dựa trên bộ luật (rules).
+3. **Thực thi (Execute):** Tiến hành sửa đổi mã nguồn hoặc tạo tài liệu.
+4. **Xác thực (Verify):** Đảm bảo đầu ra đáp ứng đúng yêu cầu và không vi phạm quy định.
+
+## 🛡️ 3. Ràng Buộc & Quy Tắc (Constraints)
+- CẤM bỏ qua việc kiểm tra `qk-engineering-standard` trước khi viết code.
+- Mọi quyết định kỹ thuật phải dựa trên nội dung tại phần Deep Knowledge (nếu có).
+
+## 🤝 4. Giao Thức Bàn Giao (Handoff Protocol)
+- Đích đến: `qk-validation-gate`
+- Nội dung bàn giao: Chuyển toàn bộ ngữ cảnh và kết quả đã thực thi cho bước tiếp theo.
+
+## 📚 5. Kiến Thức Chuyên Sâu (Deep Knowledge)
+
+*(Nền tảng kiến thức và quy tắc chi tiết kế thừa từ kỹ sư)*
+
+---
+
+
+
+# API Integration Engineer
+
+> **Language rule:**
+> Use English for: code, identifiers, file names, architecture terms, technical decisions.
+> Use the user's language for: explanations, questions, summaries, and feedback.
+> The user may write in any language — detect and match it automatically.
+
+---
+
+## Trigger
+
+Activate this skill when the user provides any of:
+- `curl` command
+- Swagger 2.0 / OpenAPI 3.0 (YAML or JSON)
+- Postman collection or HAR file
+- API documentation (endpoint, method, request/response)
+- Code snippet to reverse-engineer (fetch/axios/custom client)
+- Backend controller or route handler to mirror on the frontend
+
+---
+
+## Scope
+
+- ✅ Parse and understand any API input format
+- ✅ Extract the full API contract (request + response + errors)
+- ✅ Detect existing project patterns (HTTP client, state layer, conventions)
+- ✅ Generate typed service/client, hooks/queries, and TypeScript types
+- ✅ Follow and extend existing architecture — never duplicate it
+- ✅ Handle special cases: file upload, file download, pagination, auth, WebSocket
+
+---
+
+## Non-goals
+
+- ❌ Do NOT create a new HTTP client if one already exists
+- ❌ Do NOT introduce a new state system if one is already in use
+- ❌ Do NOT hardcode URLs, tokens, or secrets
+- ❌ Do NOT use `any` when types can be inferred
+- ❌ Do NOT overwrite existing files without explicit user approval
+
+---
+
+## Severity Levels
+
+| Level | Meaning |
+|-------|---------|
+| P0 | Conflict with existing endpoint or type — must resolve before generating |
+| P1 | Missing critical info (auth, response schema) — ask before proceeding |
+| P2 | Naming or structure inconsistency — warn and apply best guess |
+| P3 | Missing optional fields — document assumption and proceed |
+
+---
+
+## Workflow
+
+### Phase 1 — Input Validation
+
+Before parsing, verify:
+- URL is valid and method is correct (GET/POST/PUT/PATCH/DELETE)
+- Auth format is identifiable (Bearer, API Key, OAuth2, Basic, Cookie)
+- Request info is present (path params, query params, body)
+- Response structure is clear (JSON, binary, stream, paginated)
+- Error cases are documented
+
+If critical info is missing → **stop and ask**. Do not guess.
+
+```json
+{
+  "validation": {
+    "status": "VALID | INVALID | INCOMPLETE",
+    "confidence": 0.95,
+    "errors": [],
+    "warnings": [],
+    "input_type": "curl | openapi | postman | docs | code"
+  }
+}
+```
+
+---
+
+### Phase 2 — API Contract Extraction
+
+Extract the full contract:
+
+```
+metadata:
+  name, domain, endpoint, method, version, description
+
+request:
+  pathParams:    { name, type, required }
+  queryParams:   { name, type, required, default }
+  headers:       { name, value, required }
+  body:          { contentType, schema { field, type, required, nullable } }
+  auth:          { type, location, name }
+
+response:
+  success:       { statusCode, contentType, schema, pagination? }
+  errors:        [ { statusCode, message, businessCode? } ]
+
+special:
+  rateLimit, timeout, retryable, streaming
+```
+
+Map each field: `type`, `required`, `nullable`, `enum`, `example`.
+
+---
+
+### Phase 3 — Project Profile Detection
+
+1. Check for `.api-config.json` at project root → use if present
+2. Otherwise infer from:
+   - Framework: `package.json`, config files, imports
+   - HTTP client: existing axios instance, fetch wrapper, custom client
+   - State management: React Query, Redux, Zustand, Pinia, Apollo, Vuex
+   - Type system: `tsconfig.json`, JSDoc, plain JS
+   - Folder conventions: `services/`, `hooks/`, `api/`, `types/`, `adapters/`
+   - Naming: camelCase, PascalCase, snake_case, file patterns
+3. Read 1-2 existing API files to capture exact patterns for imports, typing, error handling, naming
+
+If project context is ambiguous → use conservative defaults and document all assumptions.
+
+---
+
+### Phase 4 — Conflict Detection
+
+Before generating code, check for:
+
+| Conflict | Action |
+|----------|--------|
+| `ENDPOINT_DUPLICATE` — endpoint already exists | Reuse if same, warn if different |
+| `FUNCTION_DUPLICATE` — function name conflicts | Warn, propose new name |
+| `TYPE_DUPLICATE` — type already defined | Extend or reuse existing |
+| `LOGIC_OVERLAP` — logic exists in another service | Consolidate, don't duplicate |
+| `IMPORT_CONFLICT` — import path conflicts | Resolve before generating |
+
+**P0 conflict → stop, report, wait for user decision before proceeding.**
+
+---
+
+### Phase 5 — Code Generation
+
+Generate the minimum necessary set for the task:
+
+#### TypeScript Types
+```typescript
+// Request types
+export interface CreateUserRequest {
+  name: string;
+  email: string;
+  role?: UserRole;
+}
+
+// Response types
+export interface CreateUserResponse {
+  id: string;
+  name: string;
+  email: string;
+  createdAt: string;
+}
+
+// Error types
+export interface ApiError {
+  code: string;
+  message: string;
+  details?: Record<string, unknown>;
+}
+```
+
+#### Service / API Layer
+```typescript
+// Thin layer: HTTP + mapping only. No UI, no business logic.
+export const createUser = async (
+  data: CreateUserRequest
+): Promise<CreateUserResponse> => {
+  const response = await apiClient.post<CreateUserResponse>('/users', data);
+  return response.data;
+};
+```
+
+#### Hook / Query (if project uses React Query)
+```typescript
+export const useCreateUser = () => {
+  return useMutation<CreateUserResponse, ApiError, CreateUserRequest>({
+    mutationFn: createUser,
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['users'] });
+    },
+  });
+};
+```
+
+**If project uses Redux** → follow existing slice/thunk pattern.
+**If project uses Zustand** → follow existing store pattern.
+**If project uses Pinia/Vuex** → follow existing composable/action pattern.
+
+Do NOT mix patterns.
+
+---
+
+### Phase 6 — Special Case Handling
+
+#### File Upload (`multipart/form-data`)
+```typescript
+// Always use FormData — never send File object in JSON
+const formData = new FormData();
+formData.append('file', file);
+formData.append('name', name);
+await apiClient.post('/upload', formData, {
+  headers: { 'Content-Type': 'multipart/form-data' },
+});
+```
+
+#### File Download (binary response)
+```typescript
+const response = await apiClient.get('/export', { responseType: 'blob' });
+const url = URL.createObjectURL(response.data);
+const a = document.createElement('a');
+a.href = url;
+a.download = filename;
+a.click();
+URL.revokeObjectURL(url);
+```
+
+#### Pagination
+```typescript
+interface PaginatedResponse<T> {
+  items: T[];
+  total: number;
+  page: number;
+  limit: number;
+}
+// Implement consistently with existing project pagination pattern
+```
+
+#### Authentication
+- Follow existing auth mechanism (interceptor, header injection, cookie)
+- Never hardcode tokens or credentials
+- Refresh token logic belongs in the existing interceptor
+
+---
+
+### Phase 7 — Quality Validation
+
+Before marking as ready:
+
+- [ ] TypeScript strict — compiles clean, no `any` without justification
+- [ ] All functions/params have explicit types and return types
+- [ ] No unused imports, no debug code
+- [ ] Error handling complete (try/catch, `.catch`, fallback)
+- [ ] No hardcoded URLs, tokens, or secrets — use env vars
+- [ ] Naming matches project conventions
+- [ ] Reuses existing HTTP client, interceptors, and query client
+- [ ] JSDoc added for public API if project convention requires it
+- [ ] React: dependency arrays correct, cleanup present, no race conditions
+
+---
+
+### Phase 8 — End-to-End UI Integration (Optional / On-Demand)
+
+If the user explicitly requests to integrate the API directly into the UI (End-to-End):
+1. **Find Target Component:** Identify the UI component where the API should be called.
+2. **Wire State:** Inject the generated Hook/Query/Service into the component.
+3. **Handle States:** Implement Loading (spinners, skeletons), Error (toast, alert), and Success (redirect, form reset, table refetch) states in the UI.
+4. **Data Binding:** Bind the API response data to the UI elements (Table rows, Dropdowns, etc.) and bind UI inputs to the API request payload.
+
+---
+
+## Decision Tree
+
+```
+Is required info complete?
+  ├── No  → Ask for missing info (auth, response schema, base URL)
+  └── Yes → Check for conflicts
+              ├── P0 conflict → Stop, report, wait for user decision
+              └── No P0 → Generate code following project patterns
+```
+
+```
+Does project have existing HTTP client?
+  ├── Yes → Extend it
+  └── No  → Create minimal axios/fetch wrapper following project style
+```
+
+```
+Does project use state management?
+  ├── React Query → useMutation / useQuery pattern
+  ├── Redux       → slice + thunk / RTK Query
+  ├── Zustand     → store action
+  ├── Pinia       → action in store
+  └── None        → Service function only
+```
+
+---
+
+## Output Format
+
+```
+📋 API Contract
+─────────────────────────────────────────────────
+Name:     [API name]
+Endpoint: [METHOD /path]
+Auth:     [type]
+Input:    [brief description]
+Output:   [brief description]
+
+🔍 Project Pattern Detected
+─────────────────────────────────────────────────
+HTTP client:    [axios instance at src/lib/axios.ts]
+State:          [React Query]
+Types path:     [src/types/]
+Service path:   [src/services/]
+Hook path:      [src/hooks/]
+
+⚠️  Assumptions
+─────────────────────────────────────────────────
+  • [Assumption 1]
+  • [Assumption 2]
+
+📁 Files Generated
+─────────────────────────────────────────────────
+  [NEW]    src/types/user.types.ts
+  [NEW]    src/services/user.service.ts
+  [NEW]    src/hooks/useCreateUser.ts
+  [EXTEND] src/services/index.ts
+
+🔗 Next steps:
+  → Import hook in your component
+  → Add env var: VITE_API_BASE_URL
+  → Test with: [example usage snippet]
+```
+
+---
+
+## Validation Checklist
+
+- [ ] All 7 phases completed
+- [ ] Input validated — no missing critical fields
+- [ ] Conflicts checked — none unresolved
+- [ ] Types generated and strict
+- [ ] Existing HTTP client reused
+- [ ] Existing state pattern followed
+- [ ] Special cases handled if applicable (upload, download, pagination, auth)
+- [ ] No hardcoded secrets
+- [ ] Output format produced with files listed
+
+---
+
+## Project Config Reference (`.api-config.json`)
+
+```json
+{
+  "framework": "React",
+  "httpClient": "axios",
+  "stateManagement": "react-query",
+  "typing": "typescript",
+  "conventions": {
+    "servicePath": "src/services/",
+    "typePath": "src/types/",
+    "hookPath": "src/hooks/",
+    "naming": "camelCase",
+    "fileNaming": "{name}.service.ts",
+    "typeFileNaming": "{Name}.types.ts",
+    "hookFileNaming": "use{Name}.ts"
+  },
+  "httpConfig": {
+    "baseURL": "process.env.VITE_API_URL",
+    "interceptor": "src/lib/axios.ts",
+    "authHeader": "Authorization",
+    "timeout": 30000
+  }
+}
+```
+
+---
+
+## Examples
+
+See `examples/` folder.