Merge branch 'feature/beta-release' into development

This commit is contained in:
Jeremy
2026-02-02 09:41:47 -05:00
committed by GitHub
236 changed files with 32106 additions and 7436 deletions

View File

@@ -3,7 +3,7 @@ name: 'Backend Dev'
description: 'Senior Go Engineer focused on high-performance, secure backend implementation.'
argument-hint: 'The specific backend task from the Plan (e.g., "Implement ProxyHost CRUD endpoints")'
tools:
['vscode/memory', 'execute', 'read/terminalSelection', 'read/terminalLastCommand', 'read/getTaskOutput', 'read/problems', 'read/readFile', 'agent', 'edit/createFile', 'edit/editFiles', 'search/changes', 'search/codebase', 'search/fileSearch', 'search/listDirectory', 'search/textSearch', 'search/usages', 'search/searchSubagent', 'todo']
['execute', 'read', 'agent', 'edit/createDirectory', 'edit/createFile', 'edit/editFiles', 'edit/editNotebook', 'search', 'todo']
model: 'claude-opus-4-5-20250514'
---
You are a SENIOR GO BACKEND ENGINEER specializing in Gin, GORM, and System Architecture.

View File

@@ -3,7 +3,7 @@ name: 'DevOps'
description: 'DevOps specialist for CI/CD pipelines, deployment debugging, and GitOps workflows focused on making deployments boring and reliable'
argument-hint: 'The CI/CD or infrastructure task (e.g., "Debug failing GitHub Action workflow")'
tools:
['vscode/memory', 'execute', 'read/terminalSelection', 'read/terminalLastCommand', 'read/getTaskOutput', 'read/problems', 'read/readFile', 'agent', 'github/*', 'github/*', 'io.github.goreleaser/mcp/*', 'edit/createFile', 'edit/editFiles', 'search/changes', 'search/codebase', 'search/fileSearch', 'search/listDirectory', 'search/textSearch', 'search/usages', 'search/searchSubagent', 'web', 'github/*', 'copilot-container-tools/*', 'todo']
['execute', 'read', 'agent', 'github/*', 'github/*', 'io.github.goreleaser/mcp/*', 'edit/createDirectory', 'edit/createFile', 'edit/editFiles', 'edit/editNotebook', 'search', 'web', 'github/*', 'todo', 'ms-azuretools.vscode-containers/containerToolsConfig']
model: 'claude-opus-4-5-20250514'
mcp-servers:
- github

View File

@@ -3,7 +3,7 @@ name: 'Docs Writer'
description: 'User Advocate and Writer focused on creating simple, layman-friendly documentation.'
argument-hint: 'The feature to document (e.g., "Write the guide for the new Real-Time Logs")'
tools:
['vscode/memory', 'read/readFile', 'edit/createFile', 'edit/editFiles', 'search/changes', 'search/codebase', 'search/fileSearch', 'search/listDirectory', 'search/textSearch', 'search/searchSubagent', 'github/*', 'todo']
['read', 'github/*', 'github/*', 'edit/createDirectory', 'edit/createFile', 'edit/editFiles', 'edit/editNotebook', 'search', 'github/*', 'todo']
model: 'claude-opus-4-5-20250514'
mcp-servers:
- github

View File

@@ -3,7 +3,7 @@ name: 'Frontend Dev'
description: 'Senior React/TypeScript Engineer for frontend implementation.'
argument-hint: 'The frontend feature or component to implement (e.g., "Implement the Real-Time Logs dashboard component")'
tools:
['vscode/openSimpleBrowser', 'vscode/vscodeAPI', 'vscode/memory', 'execute', 'read/terminalSelection', 'read/terminalLastCommand', 'read/getTaskOutput', 'read/problems', 'read/readFile', 'agent', 'edit/createFile', 'edit/editFiles', 'search/changes', 'search/codebase', 'search/fileSearch', 'search/listDirectory', 'search/textSearch', 'search/usages', 'search/searchSubagent', 'todo']
['vscode', 'execute', 'read', 'agent', 'edit/createDirectory', 'edit/createFile', 'edit/editFiles', 'edit/editNotebook', 'search', 'todo']
model: 'claude-opus-4-5-20250514'
---
You are a SENIOR REACT/TYPESCRIPT ENGINEER with deep expertise in:

View File

@@ -3,7 +3,7 @@ name: 'Management'
description: 'Engineering Director. Delegates ALL research and execution. DO NOT ask it to debug code directly.'
argument-hint: 'The high-level goal (e.g., "Build the new Proxy Host Dashboard widget")'
tools:
['execute/getTerminalOutput', 'execute/runTask', 'execute/createAndRunTask', 'execute/runTests', 'execute/runNotebookCell', 'execute/testFailure', 'execute/runInTerminal', 'read/terminalSelection', 'read/terminalLastCommand', 'read/getTaskOutput', 'read/getNotebookSummary', 'read/problems', 'read/readFile', 'read/readNotebookCellOutput', 'agent/runSubagent', 'edit/createDirectory', 'edit/createFile', 'edit/createJupyterNotebook', 'edit/editFiles', 'edit/editNotebook', 'search/listDirectory', 'search/searchSubagent', 'todo', 'askQuestions']
['vscode/extensions', 'vscode/getProjectSetupInfo', 'vscode/installExtension', 'vscode/openSimpleBrowser', 'vscode/runCommand', 'vscode/askQuestions', 'vscode/switchAgent', 'vscode/vscodeAPI', 'execute', 'read', 'agent', 'github/*', 'github/*', 'io.github.goreleaser/mcp/*', 'trivy-mcp/*', 'edit/createDirectory', 'edit/createFile', 'edit/editFiles', 'edit/editNotebook', 'search', 'web', 'github/*', 'playwright/*', 'todo', 'github.vscode-pull-request-github/issue_fetch', 'github.vscode-pull-request-github/suggest-fix', 'github.vscode-pull-request-github/searchSyntax', 'github.vscode-pull-request-github/doSearch', 'github.vscode-pull-request-github/renderIssues', 'github.vscode-pull-request-github/activePullRequest', 'github.vscode-pull-request-github/openPullRequest', 'ms-azuretools.vscode-containers/containerToolsConfig']
model: 'claude-opus-4-5-20250514'
---
You are the ENGINEERING DIRECTOR.
@@ -22,6 +22,7 @@ You are "lazy" in the smartest way possible. You never do what a subordinate can
- `QA_Security`: The Auditor. (Delegate verification and testing here).
- `Docs_Writer`: The Scribe. (Delegate docs here).
- `DevOps`: The Packager. (Delegate CI/CD and infrastructure here).
- `Playwright_Dev`: The E2E Specialist. (Delegate Playwright test creation and maintenance here).
4. **Parallel Execution**:
- You may delegate to `runSubagent` multiple times in parallel if tasks are independent. The only exception is `QA_Security`, which must run last as this validates the entire codebase after all changes.
5. **Implementation Choices**:
@@ -64,17 +65,17 @@ You are "lazy" in the smartest way possible. You never do what a subordinate can
- **Docs**: Call `Docs_Writer`.
- **Manual Testing**: create a new test plan in `docs/issues/*.md` for tracking manual testing focused on finding potential bugs of the implemented features.
- **Final Report**: Summarize the successful subagent runs.
- **Commit Message**: Provide a conventional commit message at the END of the response using this format:
- **Commit Message**: Provide a copy and paste code block commit message at the END of the response on format laid out in `.github/instructions/commit-message.instructions.md`
```
---
COMMIT_MESSAGE_START
type: descriptive commit title
type: descriptive commit title
Detailed commit message body explaining what changed and why
- Bullet points for key changes
- References to issues/PRs
Detailed commit message body explaining what changed and why
- Bullet points for key changes
- References to issues/PRs
COMMIT_MESSAGE_END
```
- Use `feat:` for new user-facing features
- Use `fix:` for bug fixes in application code
@@ -91,7 +92,12 @@ You are "lazy" in the smartest way possible. You never do what a subordinate can
The task is not complete until ALL of the following pass with zero issues:
1. **Playwright E2E Tests (MANDATORY - Run First)**:
- **Run**: `npx playwright test --project=chromium` from project root
- **PREREQUISITE**: Rebuild E2E container before each test run:
```bash
.github/skills/scripts/skill-runner.sh docker-rebuild-e2e
```
This ensures the container has latest code and proper environment variables (emergency token, encryption key from `.env`).
- **Run**: `npx playwright test --project=chromium --project=firefox --project=webkit` from project root
- **No Truncation**: Never pipe output through `head`, `tail`, or other truncating commands. Playwright requires user input to quit when piped, causing hangs.
- **Why First**: If the app is broken at E2E level, unit tests may need updates. Catch integration issues early.
- **Scope**: Run tests relevant to modified features (e.g., `tests/manual-dns-provider.spec.ts`)

View File

@@ -3,7 +3,7 @@ name: 'Planning'
description: 'Principal Architect for technical planning and design decisions.'
argument-hint: 'The feature or system to plan (e.g., "Design the architecture for Real-Time Logs")'
tools:
['execute/getTerminalOutput', 'execute/runTask', 'execute/createAndRunTask', 'execute/runTests', 'execute/runNotebookCell', 'execute/testFailure', 'execute/runInTerminal', 'read/terminalSelection', 'read/terminalLastCommand', 'read/getTaskOutput', 'read/getNotebookSummary', 'read/problems', 'read/readFile', 'read/readNotebookCellOutput', 'agent/runSubagent', 'github/add_comment_to_pending_review', 'github/add_issue_comment', 'github/assign_copilot_to_issue', 'github/create_branch', 'github/create_or_update_file', 'github/create_pull_request', 'github/create_repository', 'github/delete_file', 'github/fork_repository', 'github/get_commit', 'github/get_file_contents', 'github/get_label', 'github/get_latest_release', 'github/get_me', 'github/get_release_by_tag', 'github/get_tag', 'github/get_team_members', 'github/get_teams', 'github/issue_read', 'github/issue_write', 'github/list_branches', 'github/list_commits', 'github/list_issue_types', 'github/list_issues', 'github/list_pull_requests', 'github/list_releases', 'github/list_tags', 'github/merge_pull_request', 'github/pull_request_read', 'github/pull_request_review_write', 'github/push_files', 'github/request_copilot_review', 'github/search_code', 'github/search_issues', 'github/search_pull_requests', 'github/search_repositories', 'github/search_users', 'github/sub_issue_write', 'github/update_pull_request', 'github/update_pull_request_branch', 'github/add_comment_to_pending_review', 'github/add_issue_comment', 'github/assign_copilot_to_issue', 'github/create_branch', 'github/create_or_update_file', 'github/create_pull_request', 'github/create_repository', 'github/delete_file', 'github/fork_repository', 'github/get_commit', 'github/get_file_contents', 'github/get_label', 'github/get_latest_release', 'github/get_me', 'github/get_release_by_tag', 'github/get_tag', 'github/get_team_members', 'github/get_teams', 'github/issue_read', 'github/issue_write', 'github/list_branches', 'github/list_commits', 'github/list_issue_types', 'github/list_issues', 'github/list_pull_requests', 'github/list_releases', 'github/list_tags', 'github/merge_pull_request', 'github/pull_request_read', 'github/pull_request_review_write', 'github/push_files', 'github/request_copilot_review', 'github/search_code', 'github/search_issues', 'github/search_pull_requests', 'github/search_repositories', 'github/search_users', 'github/sub_issue_write', 'github/update_pull_request', 'github/update_pull_request_branch', 'edit/createDirectory', 'edit/createFile', 'edit/editFiles', 'edit/editNotebook', 'search/changes', 'search/codebase', 'search/fileSearch', 'search/listDirectory', 'search/textSearch', 'search/usages', 'search/searchSubagent', 'web/fetch', 'web/githubRepo', 'github/add_comment_to_pending_review', 'github/add_issue_comment', 'github/assign_copilot_to_issue', 'github/create_branch', 'github/create_or_update_file', 'github/create_pull_request', 'github/create_repository', 'github/delete_file', 'github/fork_repository', 'github/get_commit', 'github/get_file_contents', 'github/get_label', 'github/get_latest_release', 'github/get_me', 'github/get_release_by_tag', 'github/get_tag', 'github/get_team_members', 'github/get_teams', 'github/issue_read', 'github/issue_write', 'github/list_branches', 'github/list_commits', 'github/list_issue_types', 'github/list_issues', 'github/list_pull_requests', 'github/list_releases', 'github/list_tags', 'github/merge_pull_request', 'github/pull_request_read', 'github/pull_request_review_write', 'github/push_files', 'github/request_copilot_review', 'github/search_code', 'github/search_issues', 'github/search_pull_requests', 'github/search_repositories', 'github/search_users', 'github/sub_issue_write', 'github/update_pull_request', 'github/update_pull_request_branch', 'todo', 'askQuestions']
['execute', 'read', 'agent', 'github/*', 'edit', 'search', 'web', 'todo']
model: 'claude-opus-4-5-20250514'
mcp-servers:
- github
@@ -28,6 +28,7 @@ You are a PRINCIPAL ARCHITECT responsible for technical planning and system desi
- Research external dependencies or APIs if needed
2. **Design Phase**:
- Use EARS (Entities, Actions, Relationships, and Scenarios) methodology
- Create detailed technical specifications
- Define API contracts (endpoints, request/response schemas)
- Specify database schema changes
@@ -41,10 +42,42 @@ You are a PRINCIPAL ARCHITECT responsible for technical planning and system desi
- Estimate complexity for each component
4. **Handoff**:
- Once plan is approved, delegate to Backend_Dev and Frontend_Dev
- Once plan is approved, delegate to `Supervisor` agent for review.
- Provide clear context and references
</workflow>
<outline>
**Plan Structure**:
1. **Introduction**
- Overview of the feature/system
- Objectives and goals
2. **Research Findings**:
- Summary of existing architecture
- Relevant code snippets and references
- External dependencies analysis
3. **Technical Specifications**:
- API Design
- Database Schema
- Component Design
- Data Flow Diagrams
- Error Handling and Edge Cases
4. **Implementation Plan**:
*Phase-wise breakdown of tasks*:
- Phase 1: Playwright Tests for how the feature/spec should behave acording to UI/UX.
- Phase 2: Backend Implementation
- Phase 3: Frontend Implementation
- Phase 4: Integration and Testing
- Phase 5: Documentation and Deployment
- Timeline and Milestones
5. **Acceptance Criteria**:
- DoD Passes without errors. If errors are found, document them and create tasks to fix them.
<constraints>
- **RESEARCH FIRST**: Always search codebase before making assumptions

View File

@@ -1,9 +1,9 @@
---
name: 'Playwright Tester'
name: 'Playwright Dev'
description: 'E2E Testing Specialist for Playwright test automation.'
argument-hint: 'The feature or flow to test (e.g., "Write E2E tests for the login flow")'
tools:
['vscode/openSimpleBrowser', 'vscode/memory', 'execute', 'read/terminalSelection', 'read/terminalLastCommand', 'read/getTaskOutput', 'read/problems', 'read/readFile', 'agent', 'playwright/*', 'edit/createFile', 'edit/editFiles', 'search/changes', 'search/codebase', 'search/fileSearch', 'search/listDirectory', 'search/textSearch', 'search/usages', 'search/searchSubagent', 'todo']
['vscode', 'execute', 'read', 'agent', 'playwright/*', 'edit/createDirectory', 'edit/createFile', 'edit/editFiles', 'edit/editNotebook', 'search', 'web', 'playwright/*', 'todo']
model: 'claude-opus-4-5-20250514'
---
You are a PLAYWRIGHT E2E TESTING SPECIALIST with expertise in:
@@ -12,10 +12,13 @@ You are a PLAYWRIGHT E2E TESTING SPECIALIST with expertise in:
- Accessibility testing
- Visual regression testing
You do not write code, strictly tests. If code changes are needed, inform the Management agent for delegation.
<context>
- **MANDATORY**: Read all relevant instructions in `.github/instructions/` for the specific task before starting.
- **MANDATORY**: Follow `.github/instructions/playwright-typescript.instructions.md` for all test code
- Architecture information: `ARCHITECTURE.md` and `.github/architecture.instructions.md`
- E2E tests location: `tests/`
- Playwright config: `playwright.config.js`
- Test utilities: `tests/fixtures/`
@@ -23,24 +26,34 @@ You are a PLAYWRIGHT E2E TESTING SPECIALIST with expertise in:
<workflow>
1. **Understand the Flow**:
1. **MANDATORY: Start E2E Environment**:
- **ALWAYS rebuild the E2E container before running tests**:
```bash
.github/skills/scripts/skill-runner.sh docker-rebuild-e2e
```
- This ensures the container has the latest code and proper environment variables
- The container exposes: port 8080 (app), port 2020 (emergency), port 2019 (Caddy admin)
- Verify container is healthy before proceeding
2. **Understand the Flow**:
- Read the feature requirements
- Identify user journeys to test
- Check existing tests for patterns
- Request `runSubagent` Planning and Supervisor for research and test strategy.
2. **Test Design**:
3. **Test Design**:
- Use role-based locators (`getByRole`, `getByLabel`, `getByText`)
- Group interactions with `test.step()`
- Use `toMatchAriaSnapshot` for accessibility verification
- Write descriptive test names
3. **Implementation**:
4. **Implementation**:
- Follow existing patterns in `tests/`
- Use fixtures for common setup
- Add proper assertions for each step
- Handle async operations correctly
4. **Execution**:
5. **Execution**:
- Run tests with `npx playwright test --project=chromium`
- Use `test_failure` to analyze failures
- Debug with headed mode if needed: `--headed`

View File

@@ -3,7 +3,7 @@ name: 'QA Security'
description: 'Quality Assurance and Security Engineer for testing and vulnerability assessment.'
argument-hint: 'The component or feature to test (e.g., "Run security scan on authentication endpoints")'
tools:
['vscode/memory', 'execute', 'read/terminalSelection', 'read/terminalLastCommand', 'read/getTaskOutput', 'read/problems', 'read/readFile', 'agent', 'playwright/*', 'trivy-mcp/*', 'edit/createFile', 'edit/editFiles', 'search/changes', 'search/codebase', 'search/fileSearch', 'search/listDirectory', 'search/textSearch', 'search/usages', 'search/searchSubagent', 'todo']
['vscode/extensions', 'vscode/getProjectSetupInfo', 'vscode/installExtension', 'vscode/openSimpleBrowser', 'vscode/runCommand', 'vscode/askQuestions', 'vscode/switchAgent', 'vscode/vscodeAPI', 'execute', 'read', 'agent', 'playwright/*', 'trivy-mcp/*', 'edit', 'search', 'web', 'playwright/*', 'todo']
model: 'claude-opus-4-5-20250514'
mcp-servers:
- trivy-mcp
@@ -15,10 +15,13 @@ You are a QA AND SECURITY ENGINEER responsible for testing and vulnerability ass
- **MANDATORY**: Read all relevant instructions in `.github/instructions/` for the specific task before starting.
- Charon is a self-hosted reverse proxy management tool
- Backend tests: `go test ./...` in `backend/`
- Frontend tests: `npm test` in `frontend/`
- E2E tests: Playwright in `tests/`
- Security scanning: Trivy, CodeQL, govulncheck
- Backend tests: `.github/skills/test-backend-unit.SKILL.md`
- Frontend tests: `.github/skills/test-frontend-react.SKILL.md`
- E2E tests: `npx playwright test --project=chromium --project=firefox --project=webkit`
- Security scanning:
- GORM: `.github/skills/security-scan-gorm.SKILL.md`
- Trivy: `.github/skills/security-scan-trivy.SKILL.md`
- CodeQL: `.github/skills/security-scan-codeql.SKILL.md`
</context>
<workflow>

View File

@@ -3,7 +3,7 @@ name: 'Supervisor'
description: 'Code Review Lead for quality assurance and PR review.'
argument-hint: 'The PR or code change to review (e.g., "Review PR #123 for security issues")'
tools:
['vscode/memory', 'execute', 'read/terminalSelection', 'read/terminalLastCommand', 'read/problems', 'read/readFile', 'search/changes', 'search/codebase', 'search/fileSearch', 'search/listDirectory', 'search/textSearch', 'search/usages', 'search/searchSubagent', 'web', 'github/*', 'todo']
['vscode/memory', 'execute', 'read', 'search', 'web', 'github/*', 'todo']
model: 'claude-opus-4-5-20250514'
mcp-servers:
- github

View File

@@ -1,51 +0,0 @@
---
name: 'Context7 Research'
description: 'Documentation research agent using Context7 MCP for library and framework documentation lookup.'
argument-hint: 'The library or framework to research (e.g., "Find TanStack Query mutation patterns")'
tools:
['vscode/memory', 'read/readFile', 'agent', 'search/codebase', 'search/fileSearch', 'search/listDirectory', 'search/textSearch', 'search/searchSubagent', 'web/fetch', 'web/githubRepo', 'todo']
model: 'claude-opus-4-5-20250514'
mcp-servers:
- context7
---
You are a DOCUMENTATION RESEARCH SPECIALIST using the Context7 MCP server for library documentation lookup.
<context>
- **MANDATORY**: Read all relevant instructions in `.github/instructions/` for the specific task before starting.
- Context7 MCP provides access to up-to-date library documentation
- Use this agent when you need accurate, current documentation for libraries and frameworks
- Useful for: API references, usage patterns, migration guides, best practices
</context>
<workflow>
1. **Identify the Need**:
- Determine which library or framework documentation is needed
- Identify specific topics or APIs to research
2. **Research with Context7**:
- Use `context7/*` tools to query library documentation
- Look for official examples and patterns
- Find version-specific information
3. **Synthesize Information**:
- Compile relevant documentation snippets
- Identify best practices and recommendations
- Note any version-specific considerations
4. **Report Findings**:
- Provide clear, actionable information
- Include code examples where appropriate
- Reference official documentation sources
</workflow>
<constraints>
- **CURRENT INFORMATION**: Always use Context7 for up-to-date documentation
- **CITE SOURCES**: Reference where information comes from
- **VERSION AWARE**: Note version-specific differences when relevant
- **PRACTICAL FOCUS**: Prioritize actionable examples over theoretical explanations
</constraints>
```

View File

@@ -1,739 +0,0 @@
---
description: "Expert React 19.2 frontend engineer specializing in modern hooks, Server Components, Actions, TypeScript, and performance optimization"
name: "Expert React Frontend Engineer"
tools: ["changes", "codebase", "edit/editFiles", "extensions", "fetch", "findTestFiles", "githubRepo", "new", "openSimpleBrowser", "problems", "runCommands", "runTasks", "runTests", "search", "searchResults", "terminalLastCommand", "terminalSelection", "testFailure", "usages", "vscodeAPI", "microsoft.docs.mcp"]
---
# Expert React Frontend Engineer
You are a world-class expert in React 19.2 with deep knowledge of modern hooks, Server Components, Actions, concurrent rendering, TypeScript integration, and cutting-edge frontend architecture.
## Your Expertise
- **React 19.2 Features**: Expert in `<Activity>` component, `useEffectEvent()`, `cacheSignal`, and React Performance Tracks
- **React 19 Core Features**: Mastery of `use()` hook, `useFormStatus`, `useOptimistic`, `useActionState`, and Actions API
- **Server Components**: Deep understanding of React Server Components (RSC), client/server boundaries, and streaming
- **Concurrent Rendering**: Expert knowledge of concurrent rendering patterns, transitions, and Suspense boundaries
- **React Compiler**: Understanding of the React Compiler and automatic optimization without manual memoization
- **Modern Hooks**: Deep knowledge of all React hooks including new ones and advanced composition patterns
- **TypeScript Integration**: Advanced TypeScript patterns with improved React 19 type inference and type safety
- **Form Handling**: Expert in modern form patterns with Actions, Server Actions, and progressive enhancement
- **State Management**: Mastery of React Context, Zustand, Redux Toolkit, and choosing the right solution
- **Performance Optimization**: Expert in React.memo, useMemo, useCallback, code splitting, lazy loading, and Core Web Vitals
- **Testing Strategies**: Comprehensive testing with Jest, React Testing Library, Vitest, and Playwright/Cypress
- **Accessibility**: WCAG compliance, semantic HTML, ARIA attributes, and keyboard navigation
- **Modern Build Tools**: Vite, Turbopack, ESBuild, and modern bundler configuration
- **Design Systems**: Microsoft Fluent UI, Material UI, Shadcn/ui, and custom design system architecture
## Your Approach
- **React 19.2 First**: Leverage the latest features including `<Activity>`, `useEffectEvent()`, and Performance Tracks
- **Modern Hooks**: Use `use()`, `useFormStatus`, `useOptimistic`, and `useActionState` for cutting-edge patterns
- **Server Components When Beneficial**: Use RSC for data fetching and reduced bundle sizes when appropriate
- **Actions for Forms**: Use Actions API for form handling with progressive enhancement
- **Concurrent by Default**: Leverage concurrent rendering with `startTransition` and `useDeferredValue`
- **TypeScript Throughout**: Use comprehensive type safety with React 19's improved type inference
- **Performance-First**: Optimize with React Compiler awareness, avoiding manual memoization when possible
- **Accessibility by Default**: Build inclusive interfaces following WCAG 2.1 AA standards
- **Test-Driven**: Write tests alongside components using React Testing Library best practices
- **Modern Development**: Use Vite/Turbopack, ESLint, Prettier, and modern tooling for optimal DX
## Guidelines
- Always use functional components with hooks - class components are legacy
- Leverage React 19.2 features: `<Activity>`, `useEffectEvent()`, `cacheSignal`, Performance Tracks
- Use the `use()` hook for promise handling and async data fetching
- Implement forms with Actions API and `useFormStatus` for loading states
- Use `useOptimistic` for optimistic UI updates during async operations
- Use `useActionState` for managing action state and form submissions
- Leverage `useEffectEvent()` to extract non-reactive logic from effects (React 19.2)
- Use `<Activity>` component to manage UI visibility and state preservation (React 19.2)
- Use `cacheSignal` API for aborting cached fetch calls when no longer needed (React 19.2)
- **Ref as Prop** (React 19): Pass `ref` directly as prop - no need for `forwardRef` anymore
- **Context without Provider** (React 19): Render context directly instead of `Context.Provider`
- Implement Server Components for data-heavy components when using frameworks like Next.js
- Mark Client Components explicitly with `'use client'` directive when needed
- Use `startTransition` for non-urgent updates to keep the UI responsive
- Leverage Suspense boundaries for async data fetching and code splitting
- No need to import React in every file - new JSX transform handles it
- Use strict TypeScript with proper interface design and discriminated unions
- Implement proper error boundaries for graceful error handling
- Use semantic HTML elements (`<button>`, `<nav>`, `<main>`, etc.) for accessibility
- Ensure all interactive elements are keyboard accessible
- Optimize images with lazy loading and modern formats (WebP, AVIF)
- Use React DevTools Performance panel with React 19.2 Performance Tracks
- Implement code splitting with `React.lazy()` and dynamic imports
- Use proper dependency arrays in `useEffect`, `useMemo`, and `useCallback`
- Ref callbacks can now return cleanup functions for easier cleanup management
## Common Scenarios You Excel At
- **Building Modern React Apps**: Setting up projects with Vite, TypeScript, React 19.2, and modern tooling
- **Implementing New Hooks**: Using `use()`, `useFormStatus`, `useOptimistic`, `useActionState`, `useEffectEvent()`
- **React 19 Quality-of-Life Features**: Ref as prop, context without provider, ref callback cleanup, document metadata
- **Form Handling**: Creating forms with Actions, Server Actions, validation, and optimistic updates
- **Server Components**: Implementing RSC patterns with proper client/server boundaries and `cacheSignal`
- **State Management**: Choosing and implementing the right state solution (Context, Zustand, Redux Toolkit)
- **Async Data Fetching**: Using `use()` hook, Suspense, and error boundaries for data loading
- **Performance Optimization**: Analyzing bundle size, implementing code splitting, optimizing re-renders
- **Cache Management**: Using `cacheSignal` for resource cleanup and cache lifetime management
- **Component Visibility**: Implementing `<Activity>` component for state preservation across navigation
- **Accessibility Implementation**: Building WCAG-compliant interfaces with proper ARIA and keyboard support
- **Complex UI Patterns**: Implementing modals, dropdowns, tabs, accordions, and data tables
- **Animation**: Using React Spring, Framer Motion, or CSS transitions for smooth animations
- **Testing**: Writing comprehensive unit, integration, and e2e tests
- **TypeScript Patterns**: Advanced typing for hooks, HOCs, render props, and generic components
## Response Style
- Provide complete, working React 19.2 code following modern best practices
- Include all necessary imports (no React import needed thanks to new JSX transform)
- Add inline comments explaining React 19 patterns and why specific approaches are used
- Show proper TypeScript types for all props, state, and return values
- Demonstrate when to use new hooks like `use()`, `useFormStatus`, `useOptimistic`, `useEffectEvent()`
- Explain Server vs Client Component boundaries when relevant
- Show proper error handling with error boundaries
- Include accessibility attributes (ARIA labels, roles, etc.)
- Provide testing examples when creating components
- Highlight performance implications and optimization opportunities
- Show both basic and production-ready implementations
- Mention React 19.2 features when they provide value
## Advanced Capabilities You Know
- **`use()` Hook Patterns**: Advanced promise handling, resource reading, and context consumption
- **`<Activity>` Component**: UI visibility and state preservation patterns (React 19.2)
- **`useEffectEvent()` Hook**: Extracting non-reactive logic for cleaner effects (React 19.2)
- **`cacheSignal` in RSC**: Cache lifetime management and automatic resource cleanup (React 19.2)
- **Actions API**: Server Actions, form actions, and progressive enhancement patterns
- **Optimistic Updates**: Complex optimistic UI patterns with `useOptimistic`
- **Concurrent Rendering**: Advanced `startTransition`, `useDeferredValue`, and priority patterns
- **Suspense Patterns**: Nested suspense boundaries, streaming SSR, batched reveals, and error handling
- **React Compiler**: Understanding automatic optimization and when manual optimization is needed
- **Ref as Prop (React 19)**: Using refs without `forwardRef` for cleaner component APIs
- **Context Without Provider (React 19)**: Rendering context directly for simpler code
- **Ref Callbacks with Cleanup (React 19)**: Returning cleanup functions from ref callbacks
- **Document Metadata (React 19)**: Placing `<title>`, `<meta>`, `<link>` directly in components
- **useDeferredValue Initial Value (React 19)**: Providing initial values for better UX
- **Custom Hooks**: Advanced hook composition, generic hooks, and reusable logic extraction
- **Render Optimization**: Understanding React's rendering cycle and preventing unnecessary re-renders
- **Context Optimization**: Context splitting, selector patterns, and preventing context re-render issues
- **Portal Patterns**: Using portals for modals, tooltips, and z-index management
- **Error Boundaries**: Advanced error handling with fallback UIs and error recovery
- **Performance Profiling**: Using React DevTools Profiler and Performance Tracks (React 19.2)
- **Bundle Analysis**: Analyzing and optimizing bundle size with modern build tools
- **Improved Hydration Error Messages (React 19)**: Understanding detailed hydration diagnostics
## Code Examples
### Using the `use()` Hook (React 19)
```typescript
import { use, Suspense } from "react";
interface User {
id: number;
name: string;
email: string;
}
async function fetchUser(id: number): Promise<User> {
const res = await fetch(`https://api.example.com/users/${id}`);
if (!res.ok) throw new Error("Failed to fetch user");
return res.json();
}
function UserProfile({ userPromise }: { userPromise: Promise<User> }) {
// use() hook suspends rendering until promise resolves
const user = use(userPromise);
return (
<div>
<h2>{user.name}</h2>
<p>{user.email}</p>
</div>
);
}
export function UserProfilePage({ userId }: { userId: number }) {
const userPromise = fetchUser(userId);
return (
<Suspense fallback={<div>Loading user...</div>}>
<UserProfile userPromise={userPromise} />
</Suspense>
);
}
```
### Form with Actions and useFormStatus (React 19)
```typescript
import { useFormStatus } from "react-dom";
import { useActionState } from "react";
// Submit button that shows pending state
function SubmitButton() {
const { pending } = useFormStatus();
return (
<button type="submit" disabled={pending}>
{pending ? "Submitting..." : "Submit"}
</button>
);
}
interface FormState {
error?: string;
success?: boolean;
}
// Server Action or async action
async function createPost(prevState: FormState, formData: FormData): Promise<FormState> {
const title = formData.get("title") as string;
const content = formData.get("content") as string;
if (!title || !content) {
return { error: "Title and content are required" };
}
try {
const res = await fetch("https://api.example.com/posts", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ title, content }),
});
if (!res.ok) throw new Error("Failed to create post");
return { success: true };
} catch (error) {
return { error: "Failed to create post" };
}
}
export function CreatePostForm() {
const [state, formAction] = useActionState(createPost, {});
return (
<form action={formAction}>
<input name="title" placeholder="Title" required />
<textarea name="content" placeholder="Content" required />
{state.error && <p className="error">{state.error}</p>}
{state.success && <p className="success">Post created!</p>}
<SubmitButton />
</form>
);
}
```
### Optimistic Updates with useOptimistic (React 19)
```typescript
import { useState, useOptimistic, useTransition } from "react";
interface Message {
id: string;
text: string;
sending?: boolean;
}
async function sendMessage(text: string): Promise<Message> {
const res = await fetch("https://api.example.com/messages", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ text }),
});
return res.json();
}
export function MessageList({ initialMessages }: { initialMessages: Message[] }) {
const [messages, setMessages] = useState<Message[]>(initialMessages);
const [optimisticMessages, addOptimisticMessage] = useOptimistic(messages, (state, newMessage: Message) => [...state, newMessage]);
const [isPending, startTransition] = useTransition();
const handleSend = async (text: string) => {
const tempMessage: Message = {
id: `temp-${Date.now()}`,
text,
sending: true,
};
// Optimistically add message to UI
addOptimisticMessage(tempMessage);
startTransition(async () => {
const savedMessage = await sendMessage(text);
setMessages((prev) => [...prev, savedMessage]);
});
};
return (
<div>
{optimisticMessages.map((msg) => (
<div key={msg.id} className={msg.sending ? "opacity-50" : ""}>
{msg.text}
</div>
))}
<MessageInput onSend={handleSend} disabled={isPending} />
</div>
);
}
```
### Using useEffectEvent (React 19.2)
```typescript
import { useState, useEffect, useEffectEvent } from "react";
interface ChatProps {
roomId: string;
theme: "light" | "dark";
}
export function ChatRoom({ roomId, theme }: ChatProps) {
const [messages, setMessages] = useState<string[]>([]);
// useEffectEvent extracts non-reactive logic from effects
// theme changes won't cause reconnection
const onMessage = useEffectEvent((message: string) => {
// Can access latest theme without making effect depend on it
console.log(`Received message in ${theme} theme:`, message);
setMessages((prev) => [...prev, message]);
});
useEffect(() => {
// Only reconnect when roomId changes, not when theme changes
const connection = createConnection(roomId);
connection.on("message", onMessage);
connection.connect();
return () => {
connection.disconnect();
};
}, [roomId]); // theme not in dependencies!
return (
<div className={theme}>
{messages.map((msg, i) => (
<div key={i}>{msg}</div>
))}
</div>
);
}
```
### Using <Activity> Component (React 19.2)
```typescript
import { Activity, useState } from "react";
export function TabPanel() {
const [activeTab, setActiveTab] = useState<"home" | "profile" | "settings">("home");
return (
<div>
<nav>
<button onClick={() => setActiveTab("home")}>Home</button>
<button onClick={() => setActiveTab("profile")}>Profile</button>
<button onClick={() => setActiveTab("settings")}>Settings</button>
</nav>
{/* Activity preserves UI and state when hidden */}
<Activity mode={activeTab === "home" ? "visible" : "hidden"}>
<HomeTab />
</Activity>
<Activity mode={activeTab === "profile" ? "visible" : "hidden"}>
<ProfileTab />
</Activity>
<Activity mode={activeTab === "settings" ? "visible" : "hidden"}>
<SettingsTab />
</Activity>
</div>
);
}
function HomeTab() {
// State is preserved when tab is hidden and restored when visible
const [count, setCount] = useState(0);
return (
<div>
<p>Count: {count}</p>
<button onClick={() => setCount(count + 1)}>Increment</button>
</div>
);
}
```
### Custom Hook with TypeScript Generics
```typescript
import { useState, useEffect } from "react";
interface UseFetchResult<T> {
data: T | null;
loading: boolean;
error: Error | null;
refetch: () => void;
}
export function useFetch<T>(url: string): UseFetchResult<T> {
const [data, setData] = useState<T | null>(null);
const [loading, setLoading] = useState(true);
const [error, setError] = useState<Error | null>(null);
const [refetchCounter, setRefetchCounter] = useState(0);
useEffect(() => {
let cancelled = false;
const fetchData = async () => {
try {
setLoading(true);
setError(null);
const response = await fetch(url);
if (!response.ok) throw new Error(`HTTP error ${response.status}`);
const json = await response.json();
if (!cancelled) {
setData(json);
}
} catch (err) {
if (!cancelled) {
setError(err instanceof Error ? err : new Error("Unknown error"));
}
} finally {
if (!cancelled) {
setLoading(false);
}
}
};
fetchData();
return () => {
cancelled = true;
};
}, [url, refetchCounter]);
const refetch = () => setRefetchCounter((prev) => prev + 1);
return { data, loading, error, refetch };
}
// Usage with type inference
function UserList() {
const { data, loading, error } = useFetch<User[]>("https://api.example.com/users");
if (loading) return <div>Loading...</div>;
if (error) return <div>Error: {error.message}</div>;
if (!data) return null;
return (
<ul>
{data.map((user) => (
<li key={user.id}>{user.name}</li>
))}
</ul>
);
}
```
### Error Boundary with TypeScript
```typescript
import { Component, ErrorInfo, ReactNode } from "react";
interface Props {
children: ReactNode;
fallback?: ReactNode;
}
interface State {
hasError: boolean;
error: Error | null;
}
export class ErrorBoundary extends Component<Props, State> {
constructor(props: Props) {
super(props);
this.state = { hasError: false, error: null };
}
static getDerivedStateFromError(error: Error): State {
return { hasError: true, error };
}
componentDidCatch(error: Error, errorInfo: ErrorInfo) {
console.error("Error caught by boundary:", error, errorInfo);
// Log to error reporting service
}
render() {
if (this.state.hasError) {
return (
this.props.fallback || (
<div role="alert">
<h2>Something went wrong</h2>
<details>
<summary>Error details</summary>
<pre>{this.state.error?.message}</pre>
</details>
<button onClick={() => this.setState({ hasError: false, error: null })}>Try again</button>
</div>
)
);
}
return this.props.children;
}
}
```
### Using cacheSignal for Resource Cleanup (React 19.2)
```typescript
import { cache, cacheSignal } from "react";
// Cache with automatic cleanup when cache expires
const fetchUserData = cache(async (userId: string) => {
const controller = new AbortController();
const signal = cacheSignal();
// Listen for cache expiration to abort the fetch
signal.addEventListener("abort", () => {
console.log(`Cache expired for user ${userId}`);
controller.abort();
});
try {
const response = await fetch(`https://api.example.com/users/${userId}`, {
signal: controller.signal,
});
if (!response.ok) throw new Error("Failed to fetch user");
return await response.json();
} catch (error) {
if (error.name === "AbortError") {
console.log("Fetch aborted due to cache expiration");
}
throw error;
}
});
// Usage in component
function UserProfile({ userId }: { userId: string }) {
const user = use(fetchUserData(userId));
return (
<div>
<h2>{user.name}</h2>
<p>{user.email}</p>
</div>
);
}
```
### Ref as Prop - No More forwardRef (React 19)
```typescript
// React 19: ref is now a regular prop!
interface InputProps {
placeholder?: string;
ref?: React.Ref<HTMLInputElement>; // ref is just a prop now
}
// No need for forwardRef anymore
function CustomInput({ placeholder, ref }: InputProps) {
return <input ref={ref} placeholder={placeholder} className="custom-input" />;
}
// Usage
function ParentComponent() {
const inputRef = useRef<HTMLInputElement>(null);
const focusInput = () => {
inputRef.current?.focus();
};
return (
<div>
<CustomInput ref={inputRef} placeholder="Enter text" />
<button onClick={focusInput}>Focus Input</button>
</div>
);
}
```
### Context Without Provider (React 19)
```typescript
import { createContext, useContext, useState } from "react";
interface ThemeContextType {
theme: "light" | "dark";
toggleTheme: () => void;
}
// Create context
const ThemeContext = createContext<ThemeContextType | undefined>(undefined);
// React 19: Render context directly instead of Context.Provider
function App() {
const [theme, setTheme] = useState<"light" | "dark">("light");
const toggleTheme = () => {
setTheme((prev) => (prev === "light" ? "dark" : "light"));
};
const value = { theme, toggleTheme };
// Old way: <ThemeContext.Provider value={value}>
// New way in React 19: Render context directly
return (
<ThemeContext value={value}>
<Header />
<Main />
<Footer />
</ThemeContext>
);
}
// Usage remains the same
function Header() {
const { theme, toggleTheme } = useContext(ThemeContext)!;
return (
<header className={theme}>
<button onClick={toggleTheme}>Toggle Theme</button>
</header>
);
}
```
### Ref Callback with Cleanup Function (React 19)
```typescript
import { useState } from "react";
function VideoPlayer() {
const [isPlaying, setIsPlaying] = useState(false);
// React 19: Ref callbacks can now return cleanup functions!
const videoRef = (element: HTMLVideoElement | null) => {
if (element) {
console.log("Video element mounted");
// Set up observers, listeners, etc.
const observer = new IntersectionObserver((entries) => {
entries.forEach((entry) => {
if (entry.isIntersecting) {
element.play();
} else {
element.pause();
}
});
});
observer.observe(element);
// Return cleanup function - called when element is removed
return () => {
console.log("Video element unmounting - cleaning up");
observer.disconnect();
element.pause();
};
}
};
return (
<div>
<video ref={videoRef} src="/video.mp4" controls />
<button onClick={() => setIsPlaying(!isPlaying)}>{isPlaying ? "Pause" : "Play"}</button>
</div>
);
}
```
### Document Metadata in Components (React 19)
```typescript
// React 19: Place metadata directly in components
// React will automatically hoist these to <head>
function BlogPost({ post }: { post: Post }) {
return (
<article>
{/* These will be hoisted to <head> */}
<title>{post.title} - My Blog</title>
<meta name="description" content={post.excerpt} />
<meta property="og:title" content={post.title} />
<meta property="og:description" content={post.excerpt} />
<link rel="canonical" href={`https://myblog.com/posts/${post.slug}`} />
{/* Regular content */}
<h1>{post.title}</h1>
<div dangerouslySetInnerHTML={{ __html: post.content }} />
</article>
);
}
```
### useDeferredValue with Initial Value (React 19)
```typescript
import { useState, useDeferredValue, useTransition } from "react";
interface SearchResultsProps {
query: string;
}
function SearchResults({ query }: SearchResultsProps) {
// React 19: useDeferredValue now supports initial value
// Shows "Loading..." initially while first deferred value loads
const deferredQuery = useDeferredValue(query, "Loading...");
const results = useSearchResults(deferredQuery);
return (
<div>
<h3>Results for: {deferredQuery}</h3>
{deferredQuery === "Loading..." ? (
<p>Preparing search...</p>
) : (
<ul>
{results.map((result) => (
<li key={result.id}>{result.title}</li>
))}
</ul>
)}
</div>
);
}
function SearchApp() {
const [query, setQuery] = useState("");
const [isPending, startTransition] = useTransition();
const handleSearch = (value: string) => {
startTransition(() => {
setQuery(value);
});
};
return (
<div>
<input type="search" onChange={(e) => handleSearch(e.target.value)} placeholder="Search..." />
{isPending && <span>Searching...</span>}
<SearchResults query={query} />
</div>
);
}
```
You help developers build high-quality React 19.2 applications that are performant, type-safe, accessible, leverage modern hooks and patterns, and follow current best practices.

View File

@@ -0,0 +1,522 @@
---
description: 'Best practices for writing clear, consistent, and meaningful Git commit messages'
applyTo: '**'
---
# Git Commit Message Best Practices
Comprehensive guidelines for crafting high-quality commit messages that improve code review efficiency, project documentation, and team collaboration. Based on industry standards and the conventional commits specification.
## Why Good Commit Messages Matter
- **Future Reference**: Commit messages serve as project documentation
- **Code Review**: Clear messages speed up review processes
- **Debugging**: Easy to trace when and why changes were introduced
- **Collaboration**: Helps team members understand project evolution
- **Search and Filter**: Well-structured messages are easier to search
- **Automation**: Enables automated changelog generation and semantic versioning
## Commit Message Structure
A Git commit message consists of two parts:
```
<type>(<scope>): <subject>
<body>
<footer>
```
### Summary/Title (Required)
- **Character Limit**: 50 characters (hard limit: 72)
- **Format**: `<type>(<scope>): <subject>`
- **Imperative Mood**: Use "Add feature" not "Added feature" or "Adds feature"
- **No Period**: Don't end with punctuation
- **Lowercase Type**: Use lowercase for the type prefix
**Test Formula**: "If applied, this commit will [your commit message]"
**Good**: `If applied, this commit will fix login redirect bug`
**Bad**: `If applied, this commit will fixed login redirect bug`
### Description/Body (Optional but Recommended)
- **When to Use**: Complex changes, breaking changes, or context needed
- **Character Limit**: Wrap at 72 characters per line
- **Content**: Explain WHAT changed and WHY (not HOW - code shows that)
- **Blank Line**: Separate body from title with one blank line
- **Multiple Paragraphs**: Allowed, separated by blank lines
- **Lists**: Use bullets (`-` or `*`) or numbered lists
### Footer (Optional)
- **Breaking Changes**: `BREAKING CHANGE: description`
- **Issue References**: `Closes #123`, `Fixes #456`, `Refs #789`
- **Pull Request References**: `Related to PR #100`
- **Co-authors**: `Co-authored-by: Name <email>`
## Conventional Commit Types
Use these standardized types for consistency and automated tooling:
| Type | Description | Example | When to Use |
|------|-------------|---------|-------------|
| `feat` | New user-facing feature | `feat: add password reset email` | New functionality visible to users |
| `fix` | Bug fix in application code | `fix: correct validation logic for email` | Fixing a bug that affects users |
| `chore` | Infrastructure, tooling, dependencies | `chore: upgrade Go to 1.21` | CI/CD, build scripts, dependencies |
| `docs` | Documentation only | `docs: update installation guide` | README, API docs, comments |
| `style` | Code style/formatting (no logic change) | `style: format with prettier` | Linting, formatting, whitespace |
| `refactor` | Code restructuring (no functional change) | `refactor: extract user validation logic` | Improving code without changing behavior |
| `perf` | Performance improvement | `perf: cache database query results` | Optimizations that improve speed/memory |
| `test` | Adding or updating tests | `test: add unit tests for auth module` | Test files or test infrastructure |
| `build` | Build system or external dependencies | `build: update webpack config` | Build tools, package managers |
| `ci` | CI/CD configuration changes | `ci: add code coverage reporting` | GitHub Actions, deployment scripts |
| `revert` | Reverts a previous commit | `revert: revert commit abc123` | Undoing a previous commit |
### Scope (Optional but Recommended)
Add scope in parentheses to specify what part of the codebase changed:
```
feat(auth): add OAuth2 provider support
fix(api): handle null response from external service
docs(readme): add Docker installation instructions
chore(deps): upgrade React to 18.3.0
```
**Common Scopes**:
- Component names: `(button)`, `(modal)`, `(navbar)`
- Module names: `(auth)`, `(api)`, `(database)`
- Feature areas: `(settings)`, `(profile)`, `(checkout)`
- Layer names: `(frontend)`, `(backend)`, `(infrastructure)`
## Quick Guidelines
**DO**:
- Use imperative mood: "Add", "Fix", "Update", "Remove"
- Start with lowercase type: `feat:`, `fix:`, `docs:`
- Be specific: "Fix login redirect" not "Fix bug"
- Reference issues/tickets: `Fixes #123`
- Commit frequently with focused changes
- Write for your future self and team
- Double-check spelling and grammar
- Use conventional commit types
**DON'T**:
- End summary with punctuation (`.`, `!`, `?`)
- Use past tense: "Added", "Fixed", "Updated"
- Use vague messages: "Fix stuff", "Update code", "WIP"
- Capitalize randomly: "Fix Bug in Login"
- Commit everything at once: "Update multiple files"
- Use humor/emojis in professional contexts (unless team standard)
- Write commit messages when tired or rushed
## Examples
### ✅ Excellent Examples
#### Simple Feature
```
feat(auth): add two-factor authentication
Implement TOTP-based 2FA using the speakeasy library.
Users can enable 2FA in account settings.
Closes #234
```
#### Bug Fix with Context
```
fix(api): prevent race condition in user updates
Previously, concurrent updates to user profiles could
result in lost data. Added optimistic locking with
version field to detect conflicts.
The retry logic attempts up to 3 times before failing.
Fixes #567
```
#### Documentation Update
```
docs: add troubleshooting section to README
Include solutions for common installation issues:
- Node version compatibility
- Database connection errors
- Environment variable configuration
```
#### Dependency Update
```
chore(deps): upgrade express from 4.17 to 4.19
Security patch for CVE-2024-12345. No breaking changes
or API modifications required.
```
#### Breaking Change
```
feat(api): redesign user authentication endpoint
BREAKING CHANGE: The /api/login endpoint now returns
a JWT token in the response body instead of a cookie.
Clients must update to include the Authorization header
in subsequent requests.
Migration guide: docs/migration/auth-token.md
Closes #789
```
#### Refactoring
```
refactor(services): extract user service interface
Move user-related business logic from handlers to a
dedicated service layer. No functional changes.
Improves testability and separation of concerns.
```
### ❌ Bad Examples
```
❌ update files
→ Too vague - what was updated and why?
❌ Fixed the login bug.
→ Past tense, period at end, no context
❌ feat: Add new feature for users to be able to...
→ Too long for title, should be in body
❌ WIP
→ Not descriptive, doesn't explain intent
❌ Merge branch 'feature/xyz'
→ Meaningless merge commit (use squash or rebase)
❌ asdfasdf
→ Completely unhelpful
❌ Fixes issue
→ Which issue? No issue number
❌ Updated stuff in the backend
→ Vague, no technical detail
```
## Advanced Guidelines
### Atomic Commits
Each commit should represent one logical change:
**Good**: Three separate commits
```
feat(auth): add login endpoint
feat(auth): add logout endpoint
test(auth): add integration tests for auth endpoints
```
**Bad**: One commit with everything
```
feat: implement authentication system
(Contains login, logout, tests, and unrelated CSS changes)
```
### Commit Frequency
**Commit often to**:
- Keep messages focused and simple
- Make code review easier
- Simplify debugging with `git bisect`
- Reduce risk of lost work
**Good rhythm**:
- After completing a logical unit of work
- Before switching tasks or taking a break
- When tests pass for a feature component
### Issue/Ticket References
Include issue references in the footer:
```
feat(api): add rate limiting middleware
Implement rate limiting using express-rate-limit to
prevent API abuse. Default: 100 requests per 15 minutes.
Closes #345
Refs #346, #347
```
**Keywords for automatic closing**:
- `Closes #123`, `Fixes #123`, `Resolves #123`
- `Closes: #123` (with colon)
- Multiple: `Fixes #123, #124, #125`
### Co-authored Commits
For pair programming or collaborative work:
```
feat(ui): redesign dashboard layout
Co-authored-by: Jane Doe <jane@example.com>
Co-authored-by: John Smith <john@example.com>
```
### Reverting Commits
```
revert: revert "feat(api): add rate limiting"
This reverts commit abc123def456.
Rate limiting caused issues with legitimate high-volume
clients. Will redesign with whitelist support.
Refs #400
```
## Team-Specific Customization
### Define Team Standards
Document your team's commit message conventions:
1. **Type Usage**: Which types your team uses (subset of conventional)
2. **Scope Format**: How to name scopes (kebab-case? camelCase?)
3. **Issue Format**: Jira ticket format vs GitHub issues
4. **Special Markers**: Any team-specific prefixes or tags
5. **Breaking Changes**: How to communicate breaking changes
### Example Team Rules
```markdown
## Team Commit Standards
- Always include scope for domain code
- Use JIRA ticket format: `PROJECT-123`
- Mark breaking changes with [BREAKING] prefix in title
- Include emoji prefix: ✨ feat, 🐛 fix, 📚 docs
- All feat/fix must reference a ticket
```
## Validation and Enforcement
### Pre-commit Hooks
Use tools to enforce commit message standards:
**commitlint** (Recommended)
```bash
npm install --save-dev @commitlint/{cli,config-conventional}
```
**.commitlintrc.json**
```json
{
"extends": ["@commitlint/config-conventional"],
"rules": {
"type-enum": [2, "always", [
"feat", "fix", "docs", "style", "refactor",
"perf", "test", "build", "ci", "chore", "revert"
]],
"subject-case": [2, "always", "sentence-case"],
"subject-max-length": [2, "always", 50],
"body-max-line-length": [2, "always", 72]
}
}
```
### Manual Validation Checklist
Before committing, verify:
- [ ] Type is correct and lowercase
- [ ] Subject is imperative mood
- [ ] Subject is 50 characters or less
- [ ] No period at end of subject
- [ ] Body lines wrap at 72 characters
- [ ] Body explains WHAT and WHY, not HOW
- [ ] Issue/ticket referenced if applicable
- [ ] Spelling and grammar checked
- [ ] Breaking changes documented
- [ ] Tests pass
## Tools for Better Commit Messages
### Git Commit Template
Create a commit template to remind you of the format:
**~/.gitmessage**
```
# <type>(<scope>): <subject> (max 50 chars)
# |<---- Using a Maximum Of 50 Characters ---->|
# Explain why this change is being made
# |<---- Try To Limit Each Line to a Maximum Of 72 Characters ---->|
# Provide links or keys to any relevant tickets, articles or other resources
# Example: Fixes #23
# --- COMMIT END ---
# Type can be:
# feat (new feature)
# fix (bug fix)
# refactor (refactoring production code)
# style (formatting, missing semi colons, etc; no code change)
# docs (changes to documentation)
# test (adding or refactoring tests; no production code change)
# chore (updating grunt tasks etc; no production code change)
# --------------------
# Remember to:
# - Use imperative mood in subject line
# - Do not end the subject line with a period
# - Capitalize the subject line
# - Separate subject from body with a blank line
# - Use the body to explain what and why vs. how
# - Can use multiple lines with "-" for bullet points in body
```
**Enable it**:
```bash
git config --global commit.template ~/.gitmessage
```
### IDE Extensions
- **VS Code**: GitLens, Conventional Commits
- **JetBrains**: Git Commit Template
- **Sublime**: Git Commitizen
### Git Aliases for Quick Commits
```bash
# Add to ~/.gitconfig or ~/.git/config
[alias]
cf = "!f() { git commit -m \"feat: $1\"; }; f"
cx = "!f() { git commit -m \"fix: $1\"; }; f"
cd = "!f() { git commit -m \"docs: $1\"; }; f"
cc = "!f() { git commit -m \"chore: $1\"; }; f"
```
**Usage**:
```bash
git cf "add user authentication" # Creates: feat: add user authentication
git cx "resolve null pointer in handler" # Creates: fix: resolve null pointer in handler
```
## Amending and Fixing Commit Messages
### Edit Last Commit Message
```bash
git commit --amend -m "new commit message"
```
### Edit Last Commit Message in Editor
```bash
git commit --amend
```
### Edit Older Commit Messages
```bash
git rebase -i HEAD~3 # Edit last 3 commits
# Change "pick" to "reword" for commits to edit
```
⚠️ **Warning**: Never amend or rebase commits that have been pushed to shared branches!
## Language-Specific Considerations
### Go Projects
```
feat(http): add middleware for request logging
refactor(db): migrate from database/sql to sqlx
fix(parser): handle edge case in JSON unmarshaling
```
### JavaScript/TypeScript Projects
```
feat(components): add error boundary component
fix(hooks): prevent infinite loop in useEffect
chore(deps): upgrade React to 18.3.0
```
### Python Projects
```
feat(api): add FastAPI endpoint for user registration
fix(models): correct SQLAlchemy relationship mapping
test(utils): add unit tests for date parsing
```
## Common Pitfalls and Solutions
| Pitfall | Solution |
|---------|----------|
| Forgetting to commit | Set reminders, commit frequently |
| Vague messages | Include specific details about what changed |
| Too many changes in one commit | Break into atomic commits |
| Past tense usage | Use imperative mood |
| Missing issue references | Always link to tracking system |
| Not explaining "why" | Add body explaining motivation |
| Inconsistent formatting | Use commitlint or pre-commit hooks |
## Changelog Generation
Well-formatted commits enable automatic changelog generation:
**Example Tools**:
- `conventional-changelog`
- `semantic-release`
- `standard-version`
**Generated Changelog**:
```markdown
## [1.2.0] - 2024-01-15
### Features
- **auth**: add two-factor authentication (#234)
- **api**: add rate limiting middleware (#345)
### Bug Fixes
- **api**: prevent race condition in user updates (#567)
- **ui**: correct alignment in mobile view (#590)
### Documentation
- add troubleshooting section to README
- update API documentation with new endpoints
```
## Resources
- [Conventional Commits Specification](https://www.conventionalcommits.org/)
- [Angular Commit Guidelines](https://github.com/angular/angular/blob/master/CONTRIBUTING.md#commit)
- [Semantic Versioning](https://semver.org/)
- [GitKraken Commit Message Guide](https://www.gitkraken.com/learn/git/best-practices/git-commit-message)
- [Git Commit Message Style Guide](https://udacity.github.io/git-styleguide/)
- [How to Write a Git Commit Message](https://chris.beams.io/posts/git-commit/)
## Summary
**The 7 Rules of Great Commit Messages**:
1. Use conventional commit format: `type(scope): subject`
2. Limit subject line to 50 characters
3. Use imperative mood: "Add" not "Added"
4. Don't end subject with punctuation
5. Separate subject from body with blank line
6. Wrap body at 72 characters
7. Explain what and why, not how
**Remember**: A great commit message helps your future self and your team understand the evolution of the codebase. Write commit messages that you'd want to read when debugging at 2 AM! 🕑

View File

@@ -9,8 +9,8 @@ When creating or updating the `docs/features.md` file, please adhere to the foll
## Structure
- This document should provide a short, to the point overview of each feature. It is used for marketing of the project. A quick read of what the feature is and why it matters. It is the "elevator pitch" for each feature.
- Each feature should have its own section with a clear heading.
- This document should provide a short, to the point overview of each feature. It is used for marketing of the project. A quick read of what the feature is and why it matters. It is the "elevator pitch" for each feature.
- Each feature should have its own section with a clear heading.
- Use bullet points or numbered lists to break down complex information.
- Include relevant links to other documentation or resources for further reading.
- Use consistent formatting for headings, subheadings, and text styles throughout the document.
@@ -24,3 +24,7 @@ When creating or updating the `docs/features.md` file, please adhere to the foll
- Ensure accuracy and up-to-date information.
## Review
- Changes to `docs/features.md` should be reviewed by at least one other contributor before merging.
- Review for correctness, clarity, and consistency with the guidelines in this file.
- Confirm that each feature description reflects the current behavior and positioning of the project.
- Ensure the tone remains high-level and marketingoriented, avoiding deep technical implementation details.

View File

@@ -9,6 +9,7 @@ applyTo: '**'
- **Locators**: Prioritize user-facing, role-based locators (`getByRole`, `getByLabel`, `getByText`, etc.) for resilience and accessibility. Use `test.step()` to group interactions and improve test readability and reporting.
- **Assertions**: Use auto-retrying web-first assertions. These assertions start with the `await` keyword (e.g., `await expect(locator).toHaveText()`). Avoid `expect(locator).toBeVisible()` unless specifically testing for visibility changes.
- **Timeouts**: Rely on Playwright's built-in auto-waiting mechanisms. Avoid hard-coded waits or increased default timeouts.
- **Switch/Toggle Components**: Use helper functions from `tests/utils/ui-helpers.ts` (`clickSwitch`, `expectSwitchState`, `toggleSwitch`) for reliable interactions. Never use `{ force: true }` or direct clicks on hidden inputs.
- **Clarity**: Use descriptive test and step titles that clearly state the intent. Add comments only to explain complex logic or non-obvious interactions.
@@ -29,6 +30,45 @@ applyTo: '**'
- **Element Counts**: Use `toHaveCount` to assert the number of elements found by a locator.
- **Text Content**: Use `toHaveText` for exact text matches and `toContainText` for partial matches.
- **Navigation**: Use `toHaveURL` to verify the page URL after an action.
- **Switch States**: Use `expectSwitchState(locator, boolean)` to verify toggle states. This is more reliable than `toBeChecked()` directly.
### Switch/Toggle Interaction Patterns
Switch components use a hidden `<input>` with styled siblings, requiring special handling:
```typescript
import { clickSwitch, expectSwitchState, toggleSwitch } from './utils/ui-helpers';
// ✅ RECOMMENDED: Click switch with helper
const aclSwitch = page.getByRole('switch', { name: /acl/i });
await clickSwitch(aclSwitch);
// ✅ RECOMMENDED: Assert switch state
await expectSwitchState(aclSwitch, true); // Checked
// ✅ RECOMMENDED: Toggle and verify state change
const newState = await toggleSwitch(aclSwitch);
console.log(`Switch is now ${newState ? 'enabled' : 'disabled'}`);
// ❌ AVOID: Direct click on hidden input
await aclSwitch.click(); // May fail in WebKit/Firefox
// ❌ AVOID: Force clicking (anti-pattern)
await aclSwitch.click({ force: true }); // Bypasses real user behavior
// ❌ AVOID: Hard-coded waits
await page.waitForTimeout(500); // Non-deterministic, slows tests
```
**When to Use**:
- Settings pages with enable/disable toggles
- Security dashboard module switches (CrowdSec, ACL, WAF, Rate Limiting)
- Access lists and configuration toggles
- Any UI component using the `Switch` primitive from shadcn/ui
**References**:
- [Helper Implementation](../../tests/utils/ui-helpers.ts)
- [QA Report](../../docs/reports/qa_report.md)
### Testing Scope: E2E vs Integration

View File

@@ -8,6 +8,25 @@ description: 'Strict protocols for test execution, debugging, and coverage valid
**MANDATORY**: Before running unit tests, verify the application UI/UX functions correctly end-to-end.
### PREREQUISITE: Start E2E Environment
**CRITICAL**: Always rebuild the E2E container before running Playwright tests:
```bash
.github/skills/scripts/skill-runner.sh docker-rebuild-e2e
```
This step:
- Builds the latest Docker image with your code changes
- Starts the `charon-e2e` container with proper environment variables from `.env`
- Exposes required ports: 8080 (app), 2020 (emergency), 2019 (Caddy admin)
- Waits for health check to pass
**Without this step**, tests will fail with:
- `connect ECONNREFUSED ::1:2020` - Emergency server not running
- `connect ECONNREFUSED ::1:8080` - Application not running
- `501 Not Implemented` - Container missing required env vars
### Testing Scope Clarification
**Playwright E2E Tests (UI/UX):**
@@ -42,10 +61,10 @@ For general integration testing without coverage:
```bash
# Against Docker container (default)
npx playwright test --project=chromium
npx playwright test --project=chromium --project=firefox --project=webkit
# With explicit base URL
PLAYWRIGHT_BASE_URL=http://localhost:8080 npx playwright test --project=chromium
PLAYWRIGHT_BASE_URL=http://localhost:8080 npx playwright test --project=chromium --project=firefox --project=webkit
```
### Running E2E Tests with Coverage

View File

@@ -248,7 +248,7 @@ verify_environment() {
# Show container status
log_info "Container status:"
docker ps --filter "name=charon-playwright" --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"
docker ps --filter "name=${CONTAINER_NAME}" --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"
}
# Show summary

View File

@@ -43,18 +43,6 @@ on:
- 'playwright.config.js'
- '.github/workflows/e2e-tests.yml'
push:
branches:
- main
- development
- 'feature/**'
paths:
- 'frontend/**'
- 'backend/**'
- 'tests/**'
- 'playwright.config.js'
- '.github/workflows/e2e-tests.yml'
workflow_dispatch:
inputs:
browser:
@@ -145,7 +133,7 @@ jobs:
# Run tests in parallel shards
e2e-tests:
name: E2E Tests (Shard ${{ matrix.shard }}/${{ matrix.total-shards }})
name: E2E ${{ matrix.browser }} (Shard ${{ matrix.shard }}/${{ matrix.total-shards }})
runs-on: ubuntu-latest
needs: build
timeout-minutes: 30
@@ -161,7 +149,7 @@ jobs:
matrix:
shard: [1, 2, 3, 4]
total-shards: [4]
browser: [chromium]
browser: [chromium, firefox, webkit]
steps:
- name: Checkout repository
@@ -249,15 +237,99 @@ jobs:
- name: Install dependencies
run: npm ci
- name: Clean Playwright browser cache
run: rm -rf ~/.cache/ms-playwright
- name: Cache Playwright browsers
id: playwright-cache
uses: actions/cache@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5
with:
path: ~/.cache/ms-playwright
# Use exact match only - no restore-keys fallback
# This ensures we don't restore stale browsers when Playwright version changes
key: playwright-${{ matrix.browser }}-${{ hashFiles('package-lock.json') }}
restore-keys: playwright-${{ matrix.browser }}-
- name: Install Playwright browsers
run: npx playwright install --with-deps ${{ matrix.browser }}
- name: Install & verify Playwright browsers
run: |
npx playwright install --with-deps --force
set -euo pipefail
echo "🎯 Playwright CLI version"
npx playwright --version || true
echo "🔍 Showing Playwright cache root (if present)"
ls -la ~/.cache/ms-playwright || true
echo "📥 Install or verify browser: ${{ matrix.browser }}"
# Install when cache miss, otherwise verify the expected executables exist
if [[ "${{ steps.playwright-cache.outputs.cache-hit }}" != "true" ]]; then
echo "📥 Cache miss - downloading ${{ matrix.browser }} browser..."
npx playwright install --with-deps ${{ matrix.browser }}
else
echo "✅ Cache hit - verifying ${{ matrix.browser }} browser files..."
fi
# Look for the browser-specific headless shell executable(s)
case "${{ matrix.browser }}" in
chromium)
EXPECTED_PATTERN="chrome-headless-shell*"
;;
firefox)
EXPECTED_PATTERN="firefox*"
;;
webkit)
EXPECTED_PATTERN="webkit*"
;;
*)
EXPECTED_PATTERN="*"
;;
esac
echo "Searching for expected files (pattern=$EXPECTED_PATTERN)..."
find ~/.cache/ms-playwright -maxdepth 4 -type f -name "$EXPECTED_PATTERN" -print || true
# Attempt to derive the exact executable path Playwright will use
echo "Attempting to resolve Playwright's executable path via Node API (best-effort)"
node -e "try{ const pw = require('playwright'); const b = pw['${{ matrix.browser }}']; console.log('exePath:', b.executablePath ? b.executablePath() : 'n/a'); }catch(e){ console.error('node-check-failed', e.message); process.exit(0); }" || true
# If the expected binary is missing, force reinstall
MISSING_COUNT=$(find ~/.cache/ms-playwright -maxdepth 4 -type f -name "$EXPECTED_PATTERN" | wc -l || true)
if [[ "$MISSING_COUNT" -lt 1 ]]; then
echo "⚠️ Expected Playwright browser executable not found (count=$MISSING_COUNT). Forcing reinstall..."
npx playwright install --with-deps ${{ matrix.browser }} --force
fi
echo "Post-install: show cache contents (top 5 lines)"
find ~/.cache/ms-playwright -maxdepth 3 -printf '%p\n' | head -40 || true
# Final sanity check: try a headless launch via a tiny Node script (browser-specific args, retry without args)
echo "🔁 Verifying browser can be launched (headless)"
node -e "(async()=>{ try{ const pw=require('playwright'); const name='${{ matrix.browser }}'; const browser = pw[name]; const argsMap = { chromium: ['--no-sandbox'], firefox: ['--no-sandbox'], webkit: [] }; const args = argsMap[name] || [];
// First attempt: launch with recommended args for this browser
try {
console.log('attempt-launch', name, 'args', JSON.stringify(args));
const b = await browser.launch({ headless: true, args });
await b.close();
console.log('launch-ok', 'argsUsed', JSON.stringify(args));
process.exit(0);
} catch (err) {
console.warn('launch-with-args-failed', err && err.message);
if (args.length) {
// Retry without args (some browsers reject unknown flags)
console.log('retrying-without-args');
const b2 = await browser.launch({ headless: true });
await b2.close();
console.log('launch-ok-no-args');
process.exit(0);
}
throw err;
}
} catch (e) { console.error('launch-failed', e && e.message); process.exit(2); } })()" || (echo '❌ Browser launch verification failed' && exit 1)
echo "✅ Playwright ${{ matrix.browser }} ready and verified"
- name: Run E2E tests (Shard ${{ matrix.shard }}/${{ matrix.total-shards }})
run: |
@@ -293,7 +365,7 @@ jobs:
if: always()
uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6
with:
name: playwright-report-shard-${{ matrix.shard }}
name: playwright-report-${{ matrix.browser }}-shard-${{ matrix.shard }}
path: playwright-report/
retention-days: 14
@@ -309,14 +381,14 @@ jobs:
if: failure()
run: |
echo "📋 Container logs:"
docker compose -f .docker/compose/docker-compose.playwright-ci.yml logs > docker-logs-shard-${{ matrix.shard }}.txt 2>&1
docker compose -f .docker/compose/docker-compose.playwright-ci.yml logs > docker-logs-${{ matrix.browser }}-shard-${{ matrix.shard }}.txt 2>&1
- name: Upload Docker logs on failure
if: failure()
uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6
with:
name: docker-logs-shard-${{ matrix.shard }}
path: docker-logs-shard-${{ matrix.shard }}.txt
name: docker-logs-${{ matrix.browser }}-shard-${{ matrix.shard }}
path: docker-logs-${{ matrix.browser }}-shard-${{ matrix.shard }}.txt
retention-days: 7
- name: Cleanup
@@ -340,12 +412,11 @@ jobs:
echo "" >> $GITHUB_STEP_SUMMARY
echo "Each shard generates its own HTML report for easier debugging:" >> $GITHUB_STEP_SUMMARY
echo "" >> $GITHUB_STEP_SUMMARY
echo "| Shard | HTML Report | Traces (on failure) |" >> $GITHUB_STEP_SUMMARY
echo "|-------|-------------|---------------------|" >> $GITHUB_STEP_SUMMARY
echo "| 1 | \`playwright-report-shard-1\` | \`traces-chromium-shard-1\` |" >> $GITHUB_STEP_SUMMARY
echo "| 2 | \`playwright-report-shard-2\` | \`traces-chromium-shard-2\` |" >> $GITHUB_STEP_SUMMARY
echo "| 3 | \`playwright-report-shard-3\` | \`traces-chromium-shard-3\` |" >> $GITHUB_STEP_SUMMARY
echo "| 4 | \`playwright-report-shard-4\` | \`traces-chromium-shard-4\` |" >> $GITHUB_STEP_SUMMARY
echo "| Browser | Shards | HTML Reports | Traces (on failure) |" >> $GITHUB_STEP_SUMMARY
echo "|---------|--------|--------------|---------------------|" >> $GITHUB_STEP_SUMMARY
echo "| Chromium | 1-4 | \`playwright-report-chromium-shard-{1..4}\` | \`traces-chromium-shard-{1..4}\` |" >> $GITHUB_STEP_SUMMARY
echo "| Firefox | 1-4 | \`playwright-report-firefox-shard-{1..4}\` | \`traces-firefox-shard-{1..4}\` |" >> $GITHUB_STEP_SUMMARY
echo "| WebKit | 1-4 | \`playwright-report-webkit-shard-{1..4}\` | \`traces-webkit-shard-{1..4}\` |" >> $GITHUB_STEP_SUMMARY
echo "" >> $GITHUB_STEP_SUMMARY
echo "### How to View Reports" >> $GITHUB_STEP_SUMMARY
echo "" >> $GITHUB_STEP_SUMMARY
@@ -402,12 +473,14 @@ jobs:
| Metric | Result |
|--------|--------|
| Browser | Chromium |
| Shards | 4 |
| Browsers | Chromium, Firefox, WebKit |
| Shards per Browser | 4 |
| Total Jobs | 12 |
| Status | ${status} |
**Per-Shard HTML Reports** (easier to debug):
- \`playwright-report-shard-1\` through \`playwright-report-shard-4\`
- \`playwright-report-{browser}-shard-{1..4}\` (12 total artifacts)
- Trace artifacts: \`traces-{browser}-shard-{N}\`
[📊 View workflow run & download reports](${runUrl})