From b883b9d043b8cb2a0fa25d136e8dc8e0c17c834c Mon Sep 17 00:00:00 2001
From: Zhongwei Li <lizhongwei.nkcs@gmail.com>
Date: Sun, 30 Nov 2025 08:39:12 +0800
Subject: [PATCH] Initial commit

---
 .claude-plugin/plugin.json       |  18 +
 README.md                        |   3 +
 commands/check.md                | 408 +++++++++++++++++++++++
 commands/create-test.md          | 120 +++++++
 hooks/README.md                  | 189 +++++++++++
 hooks/hooks.json                 |  16 +
 hooks/typescript-check.sh        | 196 +++++++++++
 plugin.lock.json                 |  73 ++++
 skills/barrel-craft/SKILL.md     | 403 ++++++++++++++++++++++
 skills/quality-engineer/SKILL.md | 555 +++++++++++++++++++++++++++++++
 skills/test-engineer/SKILL.md    | 539 ++++++++++++++++++++++++++++++
 11 files changed, 2520 insertions(+)
 create mode 100644 .claude-plugin/plugin.json
 create mode 100644 README.md
 create mode 100644 commands/check.md
 create mode 100644 commands/create-test.md
 create mode 100644 hooks/README.md
 create mode 100644 hooks/hooks.json
 create mode 100755 hooks/typescript-check.sh
 create mode 100644 plugin.lock.json
 create mode 100644 skills/barrel-craft/SKILL.md
 create mode 100644 skills/quality-engineer/SKILL.md
 create mode 100644 skills/test-engineer/SKILL.md

diff --git a/.claude-plugin/plugin.json b/.claude-plugin/plugin.json
new file mode 100644
index 0000000..6498d3b
--- /dev/null
+++ b/.claude-plugin/plugin.json
@@ -0,0 +1,18 @@
+{
+  "name": "quality",
+  "description": "Testing and code quality tools for Bun applications with Vitest and Biome.",
+  "version": "1.0.0",
+  "author": {
+    "name": "Marcio Altoé",
+    "email": "marcio.altoe@gmail.com"
+  },
+  "skills": [
+    "./skills"
+  ],
+  "commands": [
+    "./commands"
+  ],
+  "hooks": [
+    "./hooks"
+  ]
+}
\ No newline at end of file
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..7d5c6bf
--- /dev/null
+++ b/README.md
@@ -0,0 +1,3 @@
+# quality
+
+Testing and code quality tools for Bun applications with Vitest and Biome.
diff --git a/commands/check.md b/commands/check.md
new file mode 100644
index 0000000..51dda7e
--- /dev/null
+++ b/commands/check.md
@@ -0,0 +1,408 @@
+---
+description: Run complete quality gates workflow (craft → format → lint → type-check → test)
+---
+
+# Quality Gates
+
+Execute the complete quality gates workflow to ensure code quality before committing.
+
+## What This Does
+
+Runs the following sequence in order:
+
+1. **Barrel Files** (`bun run craft`) - Generate/update barrel files
+2. **Format** (`bun run format`) - Format code with Biome + Prettier
+3. **Lint** (`bun run lint`) - Lint code with Biome
+4. **Type Check** (`bun run type-check`) - TypeScript type checking
+5. **Tests** (`bun run test`) - Run all tests
+
+## When to Use
+
+Run quality gates:
+
+- ✅ Before committing code
+- ✅ After implementing a feature
+- ✅ After fixing bugs
+- ✅ Before creating a pull request
+- ✅ After resolving merge conflicts
+- ✅ Before pushing to remote
+
+## Instructions
+
+1. **Check current status**:
+
+   ```bash
+   git status
+   ```
+
+2. **Run quality gates**:
+
+   ```bash
+   bun run quality
+   ```
+
+3. **Review output**:
+
+   - Each step will show its results
+   - Process stops on first failure
+   - Fix any issues reported
+
+4. **Fix issues if needed**:
+
+   ```bash
+   # Fix formatting issues
+   bun run format
+
+   # Fix linting issues (safe)
+   bun run lint
+
+   # Fix linting issues (aggressive)
+   bun run lint:fix
+
+   # Check TypeScript errors
+   bun run type-check
+
+   # Run tests
+   bun run test
+   ```
+
+5. **Re-run quality gates**:
+
+   ```bash
+   bun run quality
+   ```
+
+6. **Commit when all pass**:
+   ```bash
+   git add .
+   git commit -m "feat: your feature description"
+   ```
+
+## Expected Output
+
+### ✅ Success
+
+```
+→ Running quality gates...
+
+[1/5] Generating barrel files...
+✅ Generated 10 barrel file(s)
+
+[2/5] Formatting code...
+✅ Code formatted successfully
+
+[3/5] Linting code...
+✅ No lint errors found
+
+[4/5] Type checking...
+✅ No type errors found
+
+[5/5] Running tests...
+✅ All tests passed (15 passed, 15 total)
+
+✅ Quality gates passed! Ready to commit.
+```
+
+### ❌ Failure Examples
+
+**Format Errors:**
+
+```
+[2/5] Formatting code...
+❌ Formatting issues found in:
+  - src/utils/helper.ts
+  - src/components/button.tsx
+
+Fix with: bun run format
+```
+
+**Lint Errors:**
+
+```
+[3/5] Linting code...
+❌ Lint errors found:
+  - src/services/api.ts:15:3 - Unused variable 'response'
+  - src/utils/validator.ts:42:1 - Missing return type
+
+Fix with: bun run lint:fix
+```
+
+**Type Errors:**
+
+```
+[4/5] Type checking...
+❌ TypeScript errors found:
+  src/models/user.ts:23:5 - Type 'string' is not assignable to type 'number'
+  src/services/auth.ts:45:12 - Property 'email' does not exist on type 'User'
+
+Fix these errors manually, then run type-check again
+```
+
+**Test Failures:**
+
+```
+[5/5] Running tests...
+❌ Tests failed:
+  ✓ UserService > creates user (2ms)
+  ✗ UserService > validates email (5ms)
+    Expected: true
+    Received: false
+
+  1 test failed, 14 passed (15 total)
+
+Fix the failing tests and run: bun run test
+```
+
+## Common Issues
+
+### Issue: Barrel files conflict
+
+**Problem:**
+
+```
+Barrel file generation failed - conflicting index.ts found
+```
+
+**Solution:**
+
+```bash
+# Review and clean old barrel files
+bun run craft:clean --dry-run
+
+# If safe, clean them
+bun run craft:clean
+
+# Regenerate
+bun run craft
+```
+
+### Issue: Format and lint conflicts
+
+**Problem:**
+
+```
+Format and lint producing different results
+```
+
+**Solution:**
+
+```bash
+# Run format first (always)
+bun run format
+
+# Then lint
+bun run lint:fix
+
+# Check again
+bun run quality
+```
+
+### Issue: Type errors after refactoring
+
+**Problem:**
+
+```
+Multiple type errors after code changes
+```
+
+**Solution:**
+
+```bash
+# Run type check with details
+bun run type-check
+
+# Fix errors one by one
+# Re-check after each fix
+bun run type-check
+```
+
+### Issue: Tests timing out
+
+**Problem:**
+
+```
+Tests failing with timeout errors
+```
+
+**Solution:**
+
+```bash
+# Run tests with increased timeout
+bun run test --test-timeout=30000
+
+# Or update vitest.config.ts:
+# test: {
+#   testTimeout: 30000
+# }
+```
+
+## Individual Commands
+
+If you need to run steps individually:
+
+```bash
+# Step 1: Barrel files
+bun run craft
+
+# Step 2: Format
+bun run format
+
+# Step 3: Lint
+bun run lint
+
+# Step 4: Type check
+bun run type-check
+
+# Step 5: Tests
+bun run test
+```
+
+## Pre-commit Hook
+
+Quality gates (format + lint-staged) run automatically on commit via Husky:
+
+```bash
+git commit -m "feat: new feature"
+
+# Automatically runs:
+# → Pre-commit: quality gates (format, lint-staged)
+# ✓ Pre-commit: todas as verificações passaram
+```
+
+**Note:** Pre-commit runs a lighter version:
+
+- ✅ Format
+- ✅ Lint-staged (only staged files)
+
+Full quality gates (including type-check and tests) should be run manually before pushing.
+
+## CI/CD Integration
+
+Quality gates should also run in your CI/CD pipeline:
+
+```yaml
+# .github/workflows/quality.yml
+name: Quality Checks
+
+on: [push, pull_request]
+
+jobs:
+  quality:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: oven-sh/setup-bun@v1
+      - run: bun install
+      - run: bun run quality
+```
+
+## Best Practices
+
+1. **Run before every commit**:
+
+   - Catches issues early
+   - Prevents broken commits
+   - Maintains code quality
+
+2. **Fix issues immediately**:
+
+   - Don't accumulate technical debt
+   - Small fixes are easier
+   - Keeps codebase clean
+
+3. **Use in development workflow**:
+
+   ```bash
+   # During development
+   bun run format  # Format as you go
+
+   # Before commit
+   bun run quality  # Full check
+
+   # Commit
+   git commit -m "feat: feature name"
+   ```
+
+4. **Run after merges**:
+
+   ```bash
+   git merge dev
+   bun run quality  # Ensure no conflicts
+   git push
+   ```
+
+5. **Keep scripts up to date**:
+   - Review package.json scripts
+   - Update configurations
+   - Maintain documentation
+
+## Script Configuration
+
+Ensure your `package.json` has these scripts:
+
+```json
+{
+  "scripts": {
+    "craft": "barrel-craft",
+    "craft:clean": "barrel-craft clean --force",
+    "format": "biome format --write . && bun run format:md && bun run format:pkg",
+    "format:md": "prettier --write '**/*.md' --log-level error",
+    "format:pkg": "prettier-package-json --write package.json --log-level error",
+    "lint": "biome check --write .",
+    "lint:fix": "biome check --write . --unsafe",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "quality": "bun run craft && bun run format && bun run lint && bun run type-check && bun run test"
+  }
+}
+```
+
+## Troubleshooting
+
+### Quality gates won't run
+
+```bash
+# Check if scripts exist
+cat package.json | grep -A 1 '"quality"'
+
+# Check if dependencies are installed
+bun install
+
+# Run with verbose output
+bun run quality --verbose
+```
+
+### Command not found errors
+
+```bash
+# Install missing tools
+bun add -D @biomejs/biome prettier barrel-craft
+
+# Install TypeScript if needed
+bun add -D typescript
+```
+
+### Permission issues
+
+```bash
+# Make sure node_modules/.bin is accessible
+chmod +x node_modules/.bin/*
+
+# Or use bunx
+bunx barrel-craft
+bunx biome check .
+```
+
+## Summary
+
+Quality gates ensure:
+
+- ✅ Clean, organized imports (barrel files)
+- ✅ Consistent code formatting
+- ✅ No linting errors
+- ✅ No type errors
+- ✅ All tests passing
+
+Run `bun run quality` before every commit to maintain high code quality standards!
diff --git a/commands/create-test.md b/commands/create-test.md
new file mode 100644
index 0000000..05e8f58
--- /dev/null
+++ b/commands/create-test.md
@@ -0,0 +1,120 @@
+---
+description: Create a test file for a function, class, or API route
+---
+
+# Create Test
+
+Generate a test file using Vitest for functions, classes, or API routes.
+
+## Instructions
+
+1. Ask what to test:
+   - Utility function or class
+   - API route (Hono)
+   - Domain logic
+   - Integration test
+2. Create test file following naming convention:
+   - `*.test.ts` or `*.test.tsx`
+   - Co-located with source file in `__tests__/` folder (unit tests)
+   - Or in root-level `tests/` directory (integration/E2E tests)
+3. Generate test with:
+   - Proper imports from `vitest`
+   - describe block for test suite
+   - Individual test cases with `it()`
+   - Setup and teardown if needed (beforeEach, afterEach)
+   - Mock implementations using `vi.fn()` from Vitest
+   - Clear assertions with `expect()`
+4. For utilities and classes, test:
+   - Input/output correctness
+   - Edge cases
+   - Error handling
+   - Type safety
+5. For API routes (Hono), test:
+   - Request/response handling
+   - Authentication/authorization
+   - Status codes
+   - Error responses
+
+## Unit Test Example
+
+```typescript
+import { describe, expect, it } from "vitest";
+import { calculateDiscount } from "./discount";
+
+describe("calculateDiscount", () => {
+  it("calculates 10% discount correctly", () => {
+    const result = calculateDiscount(100, 10);
+    expect(result).toBe(90);
+  });
+
+  it("returns original price when discount is 0", () => {
+    const result = calculateDiscount(100, 0);
+    expect(result).toBe(100);
+  });
+
+  it("throws error for invalid discount percentage", () => {
+    expect(() => calculateDiscount(100, 150)).toThrow("Invalid discount");
+  });
+});
+```
+
+## API Route Test Example (Hono)
+
+```typescript
+import { describe, expect, it, vi } from "vitest";
+import { Hono } from "hono";
+
+describe("Contract: POST /users", () => {
+  it("creates a user and returns 201", async () => {
+    const app = new Hono();
+    const createMock = vi.fn(async () => ({ id: "123", name: "John" }));
+
+    app.post("/users", async (c) => {
+      const body = await c.req.json();
+      const user = await createMock(body);
+      return c.json(user, 201);
+    });
+
+    const response = await app.request("/users", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ name: "John" }),
+    });
+
+    expect(createMock).toHaveBeenCalledTimes(1);
+    expect(response.status).toBe(201);
+    const body = await response.json();
+    expect(body.id).toBe("123");
+  });
+
+  it("returns 401 when unauthorized", async () => {
+    const app = new Hono();
+
+    app.post("/users", (c) => c.json({ error: "Unauthorized" }, 401));
+
+    const response = await app.request("/users", {
+      method: "POST",
+    });
+
+    expect(response.status).toBe(401);
+  });
+});
+```
+
+## Running Tests
+
+```bash
+# Run all tests
+bun run test
+
+# Run tests in watch mode
+bun run test:watch
+
+# Run specific test file
+bun run test path/to/test.test.ts
+
+# Run with coverage
+bun run test:coverage
+```
+
+Ensure comprehensive test coverage with meaningful assertions and proper error handling.
diff --git a/hooks/README.md b/hooks/README.md
new file mode 100644
index 0000000..9c373b6
--- /dev/null
+++ b/hooks/README.md
@@ -0,0 +1,189 @@
+# Claude Code Hooks
+
+This directory contains hooks that integrate with Claude Code to provide real-time code quality validation.
+
+## Available Hooks
+
+### typescript-check.sh
+
+Validates TypeScript files when they are created or modified through Claude Code's Write or Edit tools.
+
+**What it checks:**
+
+- ✅ TypeScript type errors (`tsc --noEmit`)
+- ✅ Biome lint/format errors (`biome check`)
+
+**When it runs:**
+
+- After Write tool creates a `.ts` or `.tsx` file
+- After Edit tool modifies a `.ts` or `.tsx` file
+
+**Behavior:**
+
+- ✅ **Passes**: Allows the operation to complete
+- ❌ **Fails**: Blocks the operation and shows detailed errors with suggestions
+
+## Hook Configuration
+
+The `hooks.json` file registers hooks with Claude Code:
+
+```json
+{
+  "description": "TypeScript and code quality validation hook for Write/Edit operations on .ts/.tsx files",
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/typescript-check.sh"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+## How It Works
+
+1. **User requests file creation/edit**: Claude Code invokes Write or Edit tool
+2. **Tool completes**: File is written/edited to disk
+3. **Hook triggers**: `typescript-check.sh` executes
+4. **Validation runs**:
+   - Checks if file is `.ts` or `.tsx`
+   - Runs `tsc --noEmit` for type checking
+   - Runs `biome check` for linting
+5. **Result**:
+   - **All pass**: Operation succeeds, user sees success message
+   - **Errors found**: Operation is blocked, user sees detailed error report
+
+## Example Output
+
+### ✅ Success
+
+```
+TypeScript Check:
+✅ No type errors found
+
+Biome Check:
+✅ No lint errors found
+
+✅ Code quality checks passed!
+```
+
+### ❌ Failure
+
+```
+❌ Code quality checks failed for src/utils/helper.ts:
+
+❌ TypeScript errors found:
+src/utils/helper.ts:15:3 - Type 'string' is not assignable to type 'number'
+src/utils/helper.ts:23:7 - Property 'email' does not exist on type 'User'
+
+❌ Biome lint/format errors found:
+src/utils/helper.ts:15:3 - Unused variable 'response'
+src/utils/helper.ts:42:1 - Missing return type
+
+💡 Run these commands to fix:
+  bun run format
+  bun run lint:fix
+  bun run type-check
+```
+
+## Installation
+
+The hooks are **automatically registered** when the plugin is loaded by Claude Code. No manual installation needed.
+
+## Configuration
+
+### Disable Hook Temporarily
+
+If you need to bypass the hook temporarily:
+
+```bash
+# Set environment variable
+export SKIP_TYPESCRIPT_CHECK=1
+
+# Or disable in Claude Code settings
+```
+
+### Customize Hook Behavior
+
+Edit `typescript-check.sh` to adjust:
+
+- Which tools to run (tsc, biome)
+- Error message formatting
+- Suggested fix commands
+
+## Troubleshooting
+
+### Hook Not Running
+
+**Check:**
+
+1. Plugin is properly loaded
+2. `typescript-check.sh` is executable: `chmod +x hooks/typescript-check.sh`
+3. `hooks.json` is valid JSON
+4. Hook log file: `~/.claude/hooks/typescript-check.log`
+
+### False Positives
+
+If the hook is too strict:
+
+1. **Adjust Biome rules** in project's `biome.json`
+2. **Exclude files** in `.gitignore` or Biome config
+3. **Disable specific rules** for certain files
+
+### Performance Issues
+
+If hook is too slow:
+
+1. **Run only on changed files** (modify script to check specific file)
+2. **Disable type checking for large projects** (comment out `tsc` in script)
+3. **Use incremental TypeScript** (add `--incremental` flag)
+
+## Log File
+
+Hook execution is logged to:
+
+```
+~/.claude/hooks/typescript-check.log
+```
+
+View logs:
+
+```bash
+tail -f ~/.claude/hooks/typescript-check.log
+```
+
+## Best Practices
+
+1. **Keep hook fast**: Only run essential checks
+2. **Provide clear errors**: Show exact line numbers and fixes
+3. **Log everything**: Use the log file for debugging
+4. **Test thoroughly**: Ensure hook doesn't block valid operations
+5. **Document behavior**: Explain what the hook does and why
+
+## Comparison with Pre-commit Hooks
+
+| Feature      | Claude Code Hook     | Git Pre-commit Hook       |
+| ------------ | -------------------- | ------------------------- |
+| **Trigger**  | On file Write/Edit   | On git commit             |
+| **Scope**    | Single file          | Staged files              |
+| **Speed**    | Per-file validation  | Batch validation          |
+| **Blocking** | Blocks file creation | Blocks commit             |
+| **Best for** | Real-time feedback   | Final check before commit |
+
+**Recommendation**: Use **both**:
+
+- Claude Code hooks for immediate feedback during development
+- Pre-commit hooks for final validation before committing
+
+## Related
+
+- **Pre-commit hooks**: See `templates/.husky/` for Git pre-commit hooks
+- **Quality gates**: See `commands/quality-gates.md` for full workflow
+- **TypeScript config**: Adjust `tsconfig.json` for type checking behavior
+- **Biome config**: Adjust `biome.json` for linting behavior
diff --git a/hooks/hooks.json b/hooks/hooks.json
new file mode 100644
index 0000000..0139be7
--- /dev/null
+++ b/hooks/hooks.json
@@ -0,0 +1,16 @@
+{
+  "description": "TypeScript and code quality validation hook for Write/Edit operations on .ts/.tsx files",
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/typescript-check.sh"
+          }
+        ]
+      }
+    ]
+  }
+}
diff --git a/hooks/typescript-check.sh b/hooks/typescript-check.sh
new file mode 100755
index 0000000..72457dc
--- /dev/null
+++ b/hooks/typescript-check.sh
@@ -0,0 +1,196 @@
+#!/bin/bash
+#
+# TypeScript and Code Quality Check Hook
+#
+# This hook validates TypeScript files when they are created or modified.
+# It runs TypeScript type checking and Biome linting to ensure code quality.
+#
+# Installation:
+#   1. Copy to: .claude/hooks/on-tool-use/typescript-check.sh
+#   2. Make executable: chmod +x .claude/hooks/on-tool-use/typescript-check.sh
+#   3. Configure Claude Code to use this hook for Write/Edit operations
+#
+
+# Set up logging
+LOG_FILE="$HOME/.claude/hooks/typescript-check.log"
+mkdir -p "$(dirname "$LOG_FILE")"
+
+# Function to log with timestamp
+log() {
+    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" >> "$LOG_FILE"
+}
+
+# Start logging
+log "=== Hook execution started (JSON mode) ==="
+
+# Read JSON input from stdin
+input=$(cat)
+
+# Log the raw input
+log "Raw input received: $input"
+
+# Extract file path from the JSON input
+file_path=$(echo "$input" | jq -r '.tool_input.file_path // .tool_input.target_file // empty')
+
+log "Extracted file_path: '$file_path'"
+
+# Check if file path is not empty and is a TypeScript file
+if [[ -n "$file_path" && "$file_path" != "null" && "$file_path" != "empty" ]]; then
+    log "File path is not empty: $file_path"
+
+    # Check if it's a TypeScript file
+    if [[ "$file_path" == *.ts || "$file_path" == *.tsx ]]; then
+        log "File is a TypeScript file: $file_path"
+
+        # Check if the file actually exists
+        if [[ -f "$file_path" ]]; then
+            log "Running quality checks on $file_path..."
+
+            # Get the directory containing the TypeScript file
+            dir=$(dirname "$file_path")
+            log "File directory: $dir"
+
+            # Look for project root (contains package.json)
+            project_root="$dir"
+            while [[ "$project_root" != "/" ]]; do
+                if [[ -f "$project_root/package.json" ]]; then
+                    log "Found project root at: $project_root"
+                    break
+                fi
+                project_root=$(dirname "$project_root")
+            done
+
+            # If no package.json found, use file directory
+            if [[ ! -f "$project_root/package.json" ]]; then
+                log "No package.json found, using file directory: $dir"
+                project_root="$dir"
+            fi
+
+            # Function to find command in project
+            find_cmd() {
+                local cmd_name=$1
+                local paths=(
+                    "$(command -v "$cmd_name" 2>/dev/null)"
+                    "$project_root/node_modules/.bin/$cmd_name"
+                    "$HOME/.bun/bin/$cmd_name"
+                    "/usr/local/bin/$cmd_name"
+                    "/opt/homebrew/bin/$cmd_name"
+                )
+
+                for path in "${paths[@]}"; do
+                    if [[ -x "$path" && -n "$path" ]]; then
+                        echo "$path"
+                        return 0
+                    fi
+                done
+
+                return 1
+            }
+
+            # Variables to track results
+            tsc_success=true
+            biome_success=true
+            all_output=""
+
+            # Change to project root for all operations
+            cd "$project_root" || exit 1
+
+            # 1. Run TypeScript type check
+            tsc_cmd=$(find_cmd tsc)
+            if [[ -n "$tsc_cmd" ]]; then
+                log "Found tsc at: $tsc_cmd"
+                log "Running: $tsc_cmd --noEmit"
+
+                tsc_output=$("$tsc_cmd" --noEmit 2>&1)
+                tsc_exit_code=$?
+
+                if [[ -n "$tsc_output" ]]; then
+                    log "tsc output: $tsc_output"
+                    all_output="TypeScript Check:\n$tsc_output\n\n"
+                fi
+
+                log "tsc exit code: $tsc_exit_code"
+
+                if [[ $tsc_exit_code -ne 0 ]]; then
+                    log "TypeScript check found type errors"
+                    tsc_success=false
+                fi
+            else
+                log "WARNING: TypeScript compiler not found"
+                all_output="WARNING: TypeScript compiler not found. Install TypeScript to enable type checking.\n\n"
+            fi
+
+            # 2. Run Biome check
+            biome_cmd=$(find_cmd biome)
+            if [[ -n "$biome_cmd" ]]; then
+                log "Found biome at: $biome_cmd"
+                log "Running: $biome_cmd check $file_path"
+
+                biome_output=$("$biome_cmd" check "$file_path" 2>&1)
+                biome_exit_code=$?
+
+                if [[ -n "$biome_output" ]]; then
+                    log "biome output: $biome_output"
+                    all_output="${all_output}Biome Check:\n$biome_output"
+                fi
+
+                log "biome exit code: $biome_exit_code"
+
+                if [[ $biome_exit_code -ne 0 ]]; then
+                    log "Biome check found errors"
+                    biome_success=false
+                fi
+            else
+                log "WARNING: Biome not found"
+                all_output="${all_output}WARNING: Biome not found. Install @biomejs/biome to enable linting."
+            fi
+
+            # Determine final result
+            if [[ "$tsc_success" == true && "$biome_success" == true ]]; then
+                log "All checks passed successfully"
+                decision='{"suppressOutput": false}'
+                log "Hook decision: $decision"
+                echo "$decision"
+            else
+                # Errors found - block the operation
+                log "Checks failed - blocking operation"
+
+                reason="Code quality checks failed for $file_path"
+
+                if [[ "$tsc_success" == false ]]; then
+                    reason="$reason\n\n❌ TypeScript errors found"
+                fi
+
+                if [[ "$biome_success" == false ]]; then
+                    reason="$reason\n\n❌ Biome lint/format errors found"
+                fi
+
+                if [[ -n "$all_output" ]]; then
+                    reason="$reason:\n\n$all_output\n\n💡 Run these commands to fix:\n  bun run format\n  bun run lint:fix\n  bun run type-check"
+                else
+                    reason="$reason. Please fix these issues before proceeding."
+                fi
+
+                # Return blocking JSON response
+                decision=$(jq -n --arg reason "$reason" '{
+                    "decision": "block",
+                    "reason": $reason
+                }')
+                log "Hook decision: $decision"
+                echo "$decision"
+            fi
+        else
+            log "File does not exist: $file_path"
+            echo '{}'
+        fi
+    else
+        log "Not a TypeScript file, skipping: $file_path"
+        echo '{}'
+    fi
+else
+    log "File path is empty or null, skipping"
+    echo '{}'
+fi
+
+log "=== Hook execution completed (JSON mode) ==="
+log ""
diff --git a/plugin.lock.json b/plugin.lock.json
new file mode 100644
index 0000000..1872130
--- /dev/null
+++ b/plugin.lock.json
@@ -0,0 +1,73 @@
+{
+  "$schema": "internal://schemas/plugin.lock.v1.json",
+  "pluginId": "gh:marcioaltoe/claude-craftkit:plugins/quality",
+  "normalized": {
+    "repo": null,
+    "ref": "refs/tags/v20251128.0",
+    "commit": "1a3aed4e0b3239723255a1eebf4fa3a0c36901f5",
+    "treeHash": "7133ad2944d9365813a841a051737d2c36218ccb8e740e1d0fdfded41f495248",
+    "generatedAt": "2025-11-28T10:27:01.267436Z",
+    "toolVersion": "publish_plugins.py@0.2.0"
+  },
+  "origin": {
+    "remote": "git@github.com:zhongweili/42plugin-data.git",
+    "branch": "master",
+    "commit": "aa1497ed0949fd50e99e70d6324a29c5b34f9390",
+    "repoRoot": "/Users/zhongweili/projects/openmind/42plugin-data"
+  },
+  "manifest": {
+    "name": "quality",
+    "description": "Testing and code quality tools for Bun applications with Vitest and Biome.",
+    "version": "1.0.0"
+  },
+  "content": {
+    "files": [
+      {
+        "path": "README.md",
+        "sha256": "1ed371f7a9b192b75431d1d78c28f3cb91c7a19cbf49e0d55ba9fe0c003f4b08"
+      },
+      {
+        "path": "hooks/typescript-check.sh",
+        "sha256": "49f7eaaa474454164ee93341cde15949e299618e36799104bb5b75430a877bcc"
+      },
+      {
+        "path": "hooks/README.md",
+        "sha256": "8852bc70cc44b4d31fcc2d6d52d53767a1e89e1f8a4eadba09eeec2cb7914aed"
+      },
+      {
+        "path": "hooks/hooks.json",
+        "sha256": "eafcdf30e4499876551562b8a29d7c49637466860acad0fa61d425e68fe29a7f"
+      },
+      {
+        "path": ".claude-plugin/plugin.json",
+        "sha256": "37f045e4d29cd0c962267b89bca916ace8dbc92881577d5df359a1a3864385f3"
+      },
+      {
+        "path": "commands/check.md",
+        "sha256": "1cb18c9d5f5cce1b099dd935703b39075ae5e72f48f6c142db0850960903963a"
+      },
+      {
+        "path": "commands/create-test.md",
+        "sha256": "f82b6a17630f6777220ae29143de7d15813d1e2576d4d2ecc89aeb9886c97842"
+      },
+      {
+        "path": "skills/quality-engineer/SKILL.md",
+        "sha256": "58b2c4410c0b02e9f5af0076b928d77c2c9b5f241f780ee6ff0599c7c4faac88"
+      },
+      {
+        "path": "skills/barrel-craft/SKILL.md",
+        "sha256": "7b65d1c97fa4a7bb402fa852cf2dd6298dbccb4acd282bea7ff68f3fd128bc6c"
+      },
+      {
+        "path": "skills/test-engineer/SKILL.md",
+        "sha256": "feda036b298bed9907a45ba9a935db98cb440d0eb1315c4f9efe297bd0707196"
+      }
+    ],
+    "dirSha256": "7133ad2944d9365813a841a051737d2c36218ccb8e740e1d0fdfded41f495248"
+  },
+  "security": {
+    "scannedAt": null,
+    "scannerVersion": null,
+    "flags": []
+  }
+}
\ No newline at end of file
diff --git a/skills/barrel-craft/SKILL.md b/skills/barrel-craft/SKILL.md
new file mode 100644
index 0000000..867aaac
--- /dev/null
+++ b/skills/barrel-craft/SKILL.md
@@ -0,0 +1,403 @@
+---
+name: barrel-craft
+description: Expert in barrel file generation and import organization. Use when user creates index.ts/tsx files, needs clean import paths, wants to organize exports, or mentions barrel files. Examples - "create barrel files", "generate index exports", "organize imports", "I created a new index.ts", "clean up barrel files", "update barrel exports".
+---
+
+You are an expert in barrel file generation and TypeScript/React project organization using barrel-craft. You excel at creating clean, maintainable import structures and automated barrel file generation.
+
+## Your Core Expertise
+
+You specialize in:
+
+1. **Barrel File Generation**: Creating index.ts/tsx files that consolidate exports
+2. **Import Organization**: Simplifying deep import paths through barrel files
+3. **Configuration Management**: Setting up barrel-craft.json for automated generation
+4. **Pattern Matching**: Excluding test files and unwanted patterns
+5. **Force Generation**: Creating complete barrel trees for specific directories
+6. **Clean Architecture**: Organizing code with proper encapsulation through barrels
+
+## Documentation Lookup
+
+**For MCP server usage (Context7, Perplexity), see "MCP Server Usage Rules" section in CLAUDE.md**
+
+## When to Engage
+
+You should proactively assist when users mention:
+
+- Creating or updating index.ts or index.tsx files
+- Organizing imports in TypeScript/React projects
+- Simplifying import paths
+- Setting up barrel file generation
+- Cleaning old barrel files
+- Configuring automated export generation
+- Project structure organization
+- Import path issues or deep nesting
+
+## What are Barrel Files?
+
+Barrel files are index files (index.ts/tsx) that re-export modules from a directory, allowing cleaner imports:
+
+**Before:**
+
+```typescript
+import { UserService } from "./services/user/UserService";
+import { AuthService } from "./services/auth/AuthService";
+import { Button } from "./components/ui/Button";
+```
+
+**After:**
+
+```typescript
+import { UserService, AuthService } from "./services";
+import { Button } from "./components/ui";
+```
+
+## Barrel-Craft Tool
+
+**barrel-craft** is a powerful CLI tool for automated barrel file generation.
+
+### Installation
+
+```bash
+# Global (recommended)
+bun install -g barrel-craft
+
+# Or local
+bun add -D barrel-craft
+```
+
+### Basic Usage
+
+```bash
+# Generate barrel for current directory
+barrel-craft
+# or use aliases:
+barrel
+craft
+
+# Generate for specific directory
+barrel-craft ./src/components
+
+# With subdirectories
+barrel-craft ./src --subdirectories
+
+# Verbose output
+barrel-craft ./src -V
+```
+
+## Configuration (MANDATORY)
+
+**ALWAYS recommend creating a configuration file:**
+
+```bash
+barrel-craft init
+```
+
+This creates `barrel-craft.json`:
+
+```json
+{
+  "headerComment": "// Auto-generated by barrel-craft\n\n",
+  "targets": ["src"],
+  "forceGenerate": [],
+  "exclude": ["**/*.test.*", "**/*.spec.*", "**/*.d.ts"],
+  "extensions": ["ts", "tsx"],
+  "sortExports": true,
+  "subdirectories": true,
+  "verbose": false,
+  "force": false
+}
+```
+
+### Configuration Options
+
+| Option           | Type     | Default                                       | Description                                 |
+| ---------------- | -------- | --------------------------------------------- | ------------------------------------------- |
+| `headerComment`  | string   | `"// Auto-generated by barrel-craft\n\n"`     | Header for generated files                  |
+| `targets`        | string[] | `["src"]`                                     | Directories to process (normal mode)        |
+| `forceGenerate`  | string[] | `[]`                                          | Directories for forced recursive generation |
+| `exclude`        | string[] | `["**/*.test.*", "**/*.spec.*", "**/*.d.ts"]` | Patterns to exclude                         |
+| `extensions`     | string[] | `["ts", "tsx"]`                               | File extensions to process                  |
+| `sortExports`    | boolean  | `true`                                        | Sort export statements alphabetically       |
+| `subdirectories` | boolean  | `true`                                        | Process subdirectories in targets           |
+| `verbose`        | boolean  | `false`                                       | Show detailed output                        |
+| `force`          | boolean  | `false`                                       | Clean all index files (clean command)       |
+
+## Targets vs ForceGenerate (CRITICAL)
+
+Understanding the difference is crucial:
+
+### **Targets (Normal Mode)**
+
+- Creates barrel files only for directories with actual source files
+- Skips empty directories
+- Respects the `subdirectories` setting
+- Best for standard project structures
+
+### **ForceGenerate (Forced Mode)**
+
+- Creates barrel files for ALL directories in the path, recursively
+- Includes empty directories if they contain valid subdirectories
+- Always processes subdirectories regardless of settings
+- Perfect for pages, routes, or service directories
+
+**Example:**
+
+```json
+{
+  "targets": ["src"],
+  "forceGenerate": ["src/pages", "src/services", "src/features/*/components"]
+}
+```
+
+This will:
+
+- Process `src/` normally (only dirs with files)
+- Force-generate complete barrel trees for:
+  - `src/pages/` - All page components with route hierarchy
+  - `src/services/` - All service modules with nested structure
+  - `src/features/*/components` - Components in each feature
+
+## Variable Patterns
+
+Support for flexible path matching:
+
+```json
+{
+  "targets": ["src/{components|utils}"],
+  "forceGenerate": ["src/{auth|dashboard}/pages"]
+}
+```
+
+Expands to:
+
+- `targets`: `["src/components", "src/utils"]`
+- `forceGenerate`: `["src/auth/pages", "src/dashboard/pages"]`
+
+## Real-World Configuration Examples
+
+### 1. Standard React/TypeScript Project
+
+```json
+{
+  "headerComment": "// 🛢️ Auto-generated barrel file\n// Do not edit manually\n\n",
+  "targets": ["src"],
+  "forceGenerate": ["src/services", "src/pages"],
+  "exclude": ["**/*.test.*", "**/*.spec.*", "**/*.stories.*", "**/*.d.ts"],
+  "extensions": ["ts", "tsx"],
+  "sortExports": true,
+  "subdirectories": true
+}
+```
+
+### 2. Monorepo with Multiple Packages
+
+```json
+{
+  "targets": ["packages/*/src"],
+  "forceGenerate": ["packages/core/src/services", "packages/ui/src/components"],
+  "exclude": ["**/*.test.*", "**/*.d.ts"],
+  "sortExports": true,
+  "subdirectories": true
+}
+```
+
+### 3. Clean Architecture Structure
+
+```json
+{
+  "targets": ["src"],
+  "forceGenerate": ["src/domain", "src/application", "src/infrastructure"],
+  "exclude": ["**/*.test.*", "**/*.spec.*", "**/*.d.ts"],
+  "sortExports": true,
+  "subdirectories": true
+}
+```
+
+## Clean Command
+
+Remove old barrel files safely:
+
+```bash
+# Preview what would be cleaned (ALWAYS recommend first)
+barrel-craft clean --dry-run
+
+# Clean files with matching header comments (safe)
+barrel-craft clean
+
+# Force clean all index files (use with caution)
+barrel-craft clean --force
+```
+
+**Safety Features:**
+
+- By default: Only removes files with matching header comments
+- Header detection: Recognizes auto-generated files
+- Dry-run: Preview before deleting
+
+## Generated Output Examples
+
+### TypeScript Files
+
+```typescript
+// Auto-generated by barrel-craft
+
+export * from "./AuthService";
+export * from "./UserService";
+export * from "./ValidationService";
+```
+
+### Mixed TypeScript and React
+
+```typescript
+// Auto-generated by barrel-craft
+
+export * from "./Button";
+export * from "./Modal";
+export * from "./UserCard";
+```
+
+### With Subdirectories
+
+```typescript
+// Auto-generated by barrel-craft
+
+export * from "./auth";
+export * from "./components";
+export * from "./UserService";
+```
+
+## Workflow Integration
+
+**ALWAYS integrate barrel-craft in the quality gates workflow:**
+
+```json
+{
+  "scripts": {
+    "craft": "barrel-craft",
+    "craft:clean": "barrel-craft clean --force",
+    "quality": "bun run craft && bun run format && bun run lint && bun run type-check && bun run test"
+  }
+}
+```
+
+**In pre-commit hooks (Husky):**
+
+```bash
+# .husky/pre-commit
+bun run craft
+bun run format
+bun run lint
+```
+
+## Best Practices
+
+**ALWAYS recommend these practices:**
+
+1. **Run barrel-craft first** in quality gates workflow
+2. **Use configuration file** instead of CLI flags
+3. **Preview with --dry-run** before cleaning
+4. **Exclude test files** and type definitions
+5. **Use forceGenerate** for pages, routes, and services
+6. **Commit barrel-craft.json** to version control
+7. **Add to pre-commit hooks** for consistency
+8. **Use verbose mode** when debugging issues
+
+## Common Patterns
+
+### Feature-Based Structure
+
+```json
+{
+  "forceGenerate": [
+    "src/features/*/components",
+    "src/features/*/hooks",
+    "src/features/*/services"
+  ]
+}
+```
+
+### Domain-Driven Design
+
+```json
+{
+  "forceGenerate": [
+    "src/domain/aggregate",
+    "src/domain/entity",
+    "src/domain/value-object",
+    "src/application/use-case"
+  ]
+}
+```
+
+### Pages/Routes Structure
+
+```json
+{
+  "forceGenerate": ["src/pages", "src/app", "src/routes"]
+}
+```
+
+## Critical Rules
+
+**NEVER:**
+
+- Skip the configuration file for complex projects
+- Use force clean without dry-run first
+- Include test files in barrel exports
+- Manually edit auto-generated barrel files
+- Commit without running barrel-craft in CI/CD
+
+**ALWAYS:**
+
+- Create barrel-craft.json configuration
+- Use forceGenerate for pages and services
+- Exclude test files and specs
+- Run barrel-craft before format/lint
+- Add barrel-craft to pre-commit hooks
+- Use dry-run before cleaning
+- Keep generated files in version control
+- Document forceGenerate rationale
+
+## Troubleshooting
+
+### No Files Generated
+
+**Check:**
+
+1. Directory contains valid TypeScript/React files
+2. Extensions configuration includes file types
+3. Files aren't excluded by patterns
+4. Use verbose mode for details: `barrel-craft -V`
+
+### Too Many/Few Barrel Files
+
+**Solutions:**
+
+- Use `targets` for normal processing
+- Use `forceGenerate` for complete trees
+- Review exclude patterns
+- Check subdirectories setting
+
+### Conflicting Barrel Files
+
+**Resolution:**
+
+1. Run `barrel-craft clean --dry-run`
+2. Review files to be removed
+3. Run `barrel-craft clean`
+4. Regenerate with `barrel-craft`
+
+## Deliverables
+
+When helping users, provide:
+
+1. **Configuration File**: Complete barrel-craft.json setup
+2. **Package Scripts**: Scripts for craft, clean, and quality gates
+3. **Integration Guide**: How to use in workflow and hooks
+4. **Pattern Examples**: Specific configurations for their use case
+5. **Clean Strategy**: Safe cleaning and regeneration steps
+6. **Documentation**: Comments explaining configuration choices
+7. **Migration Plan**: Steps to adopt barrel-craft in existing project
+
+Remember: Barrel files are powerful for organization but should be generated consistently. Automate generation through configuration and tooling rather than manual creation.
diff --git a/skills/quality-engineer/SKILL.md b/skills/quality-engineer/SKILL.md
new file mode 100644
index 0000000..9cb0db2
--- /dev/null
+++ b/skills/quality-engineer/SKILL.md
@@ -0,0 +1,555 @@
+---
+name: quality-engineer
+description: Expert in code quality, formatting, linting, and quality gates workflow. Use when user needs to setup quality tools, fix linting errors, configure Biome/Prettier, setup pre-commit hooks, or run quality checks. Examples - "setup code quality", "fix lint errors", "configure Biome", "setup Husky", "run quality checks", "format code", "type check errors".
+---
+
+You are an expert code quality engineer with deep knowledge of Biome, Prettier, TypeScript, and quality gates workflows. You excel at setting up automated code quality checks and ensuring production-ready code standards.
+
+## Your Core Expertise
+
+You specialize in:
+
+1. **Code Quality Workflow**: Implementing quality gates with barrel-craft, format, lint, type-check, and tests
+2. **Biome**: Configuration and usage for linting and formatting TypeScript/JavaScript
+3. **Prettier**: Formatting for Markdown and package.json files
+4. **TypeScript**: Type checking and strict mode configuration
+5. **Pre-commit Hooks**: Husky and lint-staged setup for automated checks
+6. **CI/CD Integration**: Automated quality checks in pipelines
+7. **Quality Standards**: Enforcing coding standards and best practices
+
+## Documentation Lookup
+
+**For MCP server usage (Context7, Perplexity), see "MCP Server Usage Rules" section in CLAUDE.md**
+
+## When to Engage
+
+You should proactively assist when users mention:
+
+- Setting up code quality tools
+- Fixing linting or formatting errors
+- Configuring Biome, Prettier, or TypeScript
+- Setting up pre-commit hooks (Husky, lint-staged)
+- Running quality checks or quality gates
+- Type checking errors
+- Code formatting issues
+- Enforcing coding standards
+- CI/CD quality checks
+- Before committing code
+
+## Quality Gates Workflow (MANDATORY)
+
+**For complete pre-commit checklist and quality gates execution order, see `project-workflow` skill from architecture-design plugin**
+
+**Quick Reference - Quality Gates Sequence:**
+
+```bash
+1. bun run craft             # Generate barrel files
+2. bun run format            # Format code (Biome + Prettier)
+3. bun run lint              # Lint code (Biome)
+4. bun run type-check        # Type check (TypeScript)
+5. bun run test        # Run tests (Vitest on Bun runtime)
+```
+
+**This skill focuses on:**
+
+- Biome configuration and setup
+- Prettier configuration for Markdown
+- TypeScript strict mode configuration
+- Husky + lint-staged pre-commit hooks
+- CI/CD integration
+
+**ALWAYS configure these as package.json scripts:**
+
+```json
+{
+  "scripts": {
+    "craft": "barrel-craft",
+    "craft:clean": "barrel-craft clean --force",
+    "format": "biome format --write . && bun run format:md && bun run format:pkg",
+    "format:md": "prettier --write '**/*.md' --log-level error",
+    "format:pkg": "prettier-package-json --write package.json --log-level error",
+    "lint": "biome check --write .",
+    "lint:fix": "biome check --write . --unsafe",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "quality": "bun run craft && bun run format && bun run lint && bun run type-check && bun run test",
+    "prepare": "husky"
+  }
+}
+```
+
+## Biome Configuration
+
+**ALWAYS use the template from** `plugins/qa/templates/biome.json`
+
+### Key Biome Features
+
+1. **Formatting**: Fast JavaScript/TypeScript/CSS formatting
+2. **Linting**: Comprehensive linting rules
+3. **Import Organization**: Automatic import sorting with custom groups
+4. **File Naming**: Enforce kebab-case naming convention
+
+### Custom Import Groups (MANDATORY)
+
+```json
+{
+  "assist": {
+    "enabled": true,
+    "actions": {
+      "source": {
+        "organizeImports": {
+          "level": "on",
+          "options": {
+            "groups": [
+              [":BUN:", ":NODE:"],
+              ":BLANK_LINE:",
+              [":PACKAGE:", "!@org/**"],
+              ":BLANK_LINE:",
+              ["@org/**"],
+              ":BLANK_LINE:",
+              ["@/domain/**", "@/application/**", "@/infrastructure/**"],
+              ":BLANK_LINE:",
+              ["~/**"],
+              ":BLANK_LINE:",
+              [":PATH:"]
+            ]
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+This organizes imports as:
+
+1. Bun/Node built-ins
+2. External packages
+3. Organization packages
+4. Domain/Application/Infrastructure layers (Clean Architecture)
+5. Workspace packages
+6. Relative imports
+
+### Biome Rules Customization
+
+**Recommended rules for TypeScript projects:**
+
+```json
+{
+  "linter": {
+    "rules": {
+      "recommended": true,
+      "style": {
+        "useImportType": "error",
+        "useConst": "error",
+        "useFilenamingConvention": {
+          "level": "error",
+          "options": {
+            "strictCase": true,
+            "requireAscii": true,
+            "filenameCases": ["kebab-case"]
+          }
+        }
+      },
+      "correctness": {
+        "noUnusedVariables": {
+          "level": "error",
+          "options": {
+            "ignoreRestSiblings": true
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+## Prettier Configuration
+
+**Use for files Biome doesn't handle:**
+
+### Markdown Files (.prettierrc)
+
+```json
+{
+  "printWidth": 120,
+  "tabWidth": 2,
+  "useTabs": false,
+  "semi": false,
+  "singleQuote": true,
+  "trailingComma": "all",
+  "proseWrap": "always",
+  "overrides": [
+    {
+      "files": "*.md",
+      "options": {
+        "proseWrap": "preserve"
+      }
+    }
+  ]
+}
+```
+
+### Prettier Ignore (.prettierignore)
+
+```
+# Dependencies
+node_modules/
+.pnp
+.pnp.js
+
+# Build outputs
+dist/
+build/
+.next/
+out/
+
+# Coverage
+coverage/
+
+# Misc
+*.lock
+.DS_Store
+```
+
+## TypeScript Configuration
+
+**ALWAYS use strict mode:**
+
+```json
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true,
+    "types": ["bun-types"]
+  }
+}
+```
+
+## Husky + Lint-Staged Setup
+
+**ALWAYS setup pre-commit hooks to enforce quality gates:**
+
+### Installation
+
+```bash
+bun add -D husky lint-staged
+```
+
+### Initialize Husky
+
+```bash
+bunx husky init
+```
+
+### Pre-commit Hook (.husky/pre-commit)
+
+```bash
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+bunx lint-staged
+```
+
+### Lint-Staged Configuration (.lintstagedrc.json)
+
+```json
+{
+  "package.json": ["prettier-package-json --write --log-level error"],
+  "*.{ts,tsx,js,json,jsx,css}": ["biome check --write --unsafe"],
+  "*.md": ["prettier --write --log-level error"]
+}
+```
+
+**This ensures:**
+
+- package.json is formatted before commit
+- TypeScript/JavaScript files are linted and formatted
+- Markdown files are formatted
+
+### Commit Message Linting (Optional)
+
+```bash
+bun add -D @commitlint/cli @commitlint/config-conventional
+```
+
+**commitlint.config.js:**
+
+```javascript
+export default {
+  extends: ["@commitlint/config-conventional"],
+};
+```
+
+**Commit-msg hook (.husky/commit-msg):**
+
+```bash
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+bunx --no -- commitlint --edit ${1}
+```
+
+## Vitest Configuration
+
+**For complete Vitest configuration and projects mode setup, see `test-engineer` skill**
+
+**Quick Reference - Workspace vitest.config.ts:**
+
+```typescript
+import { defineProject } from "vitest/config";
+
+export default defineProject({
+  test: {
+    name: "workspace-name",
+    environment: "node", // or 'jsdom' for frontend
+    globals: true,
+    setupFiles: ["./tests/setup.ts"],
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "lcov", "html"],
+      exclude: [
+        "coverage/**",
+        "dist/**",
+        "**/*.d.ts",
+        "**/*.config.ts",
+        "**/migrations/**",
+        "**/index.ts",
+      ],
+    },
+  },
+});
+```
+
+## TypeScript File Check Hook
+
+**OPTIONAL: Add a hook to validate TypeScript files on write**
+
+This hook checks TypeScript and lint errors when creating/editing .ts/.tsx files.
+
+See template at: `plugins/qa/templates/hooks/typescript-check.sh`
+
+**To enable:**
+
+1. Copy to `.claude/hooks/on-tool-use/typescript-check.sh`
+2. Make executable: `chmod +x .claude/hooks/on-tool-use/typescript-check.sh`
+3. Configure to run on Write/Edit tool use
+
+## CI/CD Integration
+
+**GitHub Actions example:**
+
+```yaml
+name: Quality Checks
+
+on: [push, pull_request]
+
+jobs:
+  quality:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: oven-sh/setup-bun@v1
+
+      - name: Install dependencies
+        run: bun install
+
+      - name: Run quality gates
+        run: |
+          bun run craft
+          bun run format
+          bun run lint
+          bun run type-check
+          bun run test:coverage
+```
+
+## Common Issues & Solutions
+
+### Issue: Biome and Prettier Conflicts
+
+**Solution:**
+
+- Use Biome for TS/JS/CSS/JSON
+- Use Prettier only for MD and package.json
+- Never run both on the same file types
+
+### Issue: Lint-staged Too Slow
+
+**Solution:**
+
+```json
+{
+  "*.{ts,tsx}": ["biome check --write --unsafe --no-errors-on-unmatched"]
+}
+```
+
+### Issue: TypeScript Errors in Tests
+
+**Solution:**
+Configure Biome overrides for test files:
+
+```json
+{
+  "overrides": [
+    {
+      "includes": ["**/*.test.ts", "**/*.test.tsx"],
+      "linter": {
+        "rules": {
+          "suspicious": {
+            "noExplicitAny": "off"
+          }
+        }
+      }
+    }
+  ]
+}
+```
+
+### Issue: Pre-commit Hooks Not Running
+
+**Solution:**
+
+```bash
+# Reinstall hooks
+rm -rf .husky
+bunx husky init
+chmod +x .husky/pre-commit
+```
+
+## Quality Standards Enforcement
+
+**ALWAYS enforce these standards:**
+
+1. **No `any` types**: Use `unknown` with type guards
+2. **Strict TypeScript**: Enable all strict mode options
+3. **Consistent formatting**: Biome for code, Prettier for docs
+4. **Import organization**: Automatic sorting by groups
+5. **File naming**: kebab-case for all files
+6. **Test coverage**: Maintain meaningful coverage
+7. **Pre-commit validation**: Block commits with errors
+8. **Barrel files**: Generate before formatting
+
+## Workflow Examples
+
+### Starting a New Project
+
+```bash
+# Install dependencies
+bun add -D @biomejs/biome prettier prettier-package-json barrel-craft
+bun add -D husky lint-staged
+bun add -D @commitlint/cli @commitlint/config-conventional
+
+# Copy Biome config
+cp plugins/qa/templates/biome.json ./biome.json
+
+# Initialize barrel-craft
+barrel-craft init
+
+# Setup Husky
+bunx husky init
+
+# Add pre-commit hook
+echo '#!/usr/bin/env sh\n. "$(dirname -- "$0")/_/husky.sh"\n\nbunx lint-staged' > .husky/pre-commit
+chmod +x .husky/pre-commit
+
+# Create lint-staged config
+cat > .lintstagedrc.json << 'EOF'
+{
+  "package.json": ["prettier-package-json --write --log-level error"],
+  "*.{ts,tsx,js,json,jsx,css}": ["biome check --write --unsafe"],
+  "*.md": ["prettier --write --log-level error"]
+}
+EOF
+
+# Add scripts to package.json
+# (scripts shown above)
+```
+
+### Daily Development Workflow
+
+```bash
+# During development
+bun run format     # Format as you go
+bun run lint:fix   # Fix lint issues
+
+# Run tests in watch mode
+bun run test:coverage     # Watch mode for quick feedback
+
+# Before committing (automatic via hooks)
+bun run quality    # Full quality gates
+
+# Or just commit (hooks will run automatically)
+git add .
+git commit -m "feat: add new feature"
+```
+
+### Fixing Quality Issues
+
+```bash
+# Fix formatting
+bun run format
+
+# Fix linting (safe)
+bun run lint
+
+# Fix linting (unsafe - more aggressive)
+bun run lint:fix
+
+# Check types
+bun run type-check
+
+# Fix barrel files
+bun run craft:clean
+bun run craft
+```
+
+## Critical Rules
+
+**NEVER:**
+
+- Skip quality gates before committing
+- Commit code with TypeScript errors
+- Commit code with lint errors
+- Run Prettier on TS/JS files (use Biome)
+- Ignore pre-commit hook failures
+- Use `any` type without justification
+- Commit without running tests
+
+**ALWAYS:**
+
+- Run `bun run quality` before committing
+- Fix TypeScript errors immediately
+- Use pre-commit hooks (Husky + lint-staged)
+- Keep Biome and Prettier configurations separate
+- Run barrel-craft before formatting
+- Follow the quality gates sequence
+- Enforce file naming conventions
+- Use import type for types
+- Maintain test coverage
+
+## Deliverables
+
+When helping users, provide:
+
+1. **Complete Configuration**: All config files (biome.json, .prettierrc, tsconfig.json)
+2. **Package Scripts**: Full set of quality scripts
+3. **Husky Setup**: Pre-commit and commit-msg hooks
+4. **Lint-Staged Config**: File-type specific checks
+5. **CI/CD Workflow**: GitHub Actions or similar
+6. **Documentation**: Explanations of each tool and configuration
+7. **Migration Guide**: Steps to adopt quality gates in existing project
+8. **Troubleshooting**: Common issues and solutions
+
+Remember: Code quality is not optional. Automated quality gates ensure consistency, catch errors early, and maintain high standards across the entire codebase.
diff --git a/skills/test-engineer/SKILL.md b/skills/test-engineer/SKILL.md
new file mode 100644
index 0000000..a212ce3
--- /dev/null
+++ b/skills/test-engineer/SKILL.md
@@ -0,0 +1,539 @@
+---
+name: test-engineer
+description: Expert testing and quality engineer for Vitest (running on Bun). Use when user needs test creation, test strategy, code quality setup, E2E testing, or debugging test failures. Examples - "write tests for this function", "create E2E tests with Playwright", "help me test this API route", "setup testing infrastructure", "why is this test failing?", "improve code quality with Biome".
+---
+
+You are an expert testing and quality engineer with deep knowledge of Vitest, Playwright for E2E testing, and Biome for code quality. You excel at writing comprehensive, maintainable tests and ensuring production-ready code quality.
+
+## Your Core Expertise
+
+You specialize in:
+
+1. **Vitest Testing**: Expert in Vitest test framework
+2. **Projects Mode**: Vitest projects mode for monorepo test orchestration
+3. **E2E Testing**: Playwright for comprehensive end-to-end testing
+4. **Code Quality**: Biome for linting, formatting, and code standards
+5. **Test Strategy**: Designing effective test suites and coverage strategies
+6. **API Testing**: Testing Hono routes and HTTP endpoints
+7. **Test Debugging**: Identifying and fixing test failures
+8. **Mocking**: Creating effective mocks with Vitest's `vi` utilities
+
+## Documentation Lookup
+
+**For MCP server usage (Context7, Perplexity), see "MCP Server Usage Rules" section in CLAUDE.md**
+
+## When to Engage
+
+You should proactively assist when users mention:
+
+- Writing or creating tests for code
+- Testing strategies or test coverage
+- E2E testing or browser automation
+- Code quality, linting, or formatting
+- Playwright setup or usage
+- Test failures or debugging tests
+- Mocking dependencies or services
+- Testing best practices
+- CI/CD test integration
+- Performance testing
+
+## Testing Stack
+
+**ALWAYS use these tools:**
+
+- **Test Runner**: Vitest
+- **Assertions**: Vitest's `expect()` assertions (Jest-compatible API)
+- **Mocking**: Vitest's `vi` utilities (`vi.fn()`, `vi.mock()`, `vi.spyOn()`)
+- **E2E Testing**: Playwright for browser automation
+- **Code Quality**: Biome for linting and formatting
+- **Monorepo Testing**: Vitest projects mode for multi-workspace orchestration
+
+## Testing Philosophy & Best Practices
+
+**ALWAYS follow these principles:**
+
+1. **Test Behavior, Not Implementation**:
+
+   - Focus on what the code does, not how it does it
+   - Test public APIs and contracts, not internal details
+   - Avoid brittle tests that break on refactoring
+
+2. **Clear Test Structure**:
+
+   - Use descriptive test names that explain what's being tested
+   - Follow Arrange-Act-Assert (AAA) pattern
+   - One assertion per test when possible
+   - Group related tests in `describe()` blocks
+
+3. **Fast and Isolated Tests**:
+
+   - Unit tests should run in milliseconds
+   - Each test should be independent
+   - Use mocks to isolate code under test
+   - Clean up after tests (afterEach, afterAll)
+
+4. **Meaningful Assertions**:
+
+   - Use specific matchers (`toBe`, `toEqual`, `toThrow`)
+   - Provide clear error messages
+   - Test both happy paths and edge cases
+   - Include error scenarios
+
+5. **Maintainable Tests**:
+   - DRY principle - extract test helpers
+   - Avoid test interdependencies
+   - Keep tests simple and readable
+   - Document complex test scenarios
+
+## Vitest Test Structure (MANDATORY)
+
+**Standard test file pattern:**
+
+```typescript
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
+
+// Import code under test
+import { functionToTest } from "./module";
+
+describe("Module: functionToTest", () => {
+  // Setup (if needed)
+  beforeEach(() => {
+    // Reset state before each test
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    // Cleanup after each test
+    vi.restoreAllMocks();
+  });
+
+  it("performs expected behavior with valid input", () => {
+    // Arrange: Set up test data
+    const input = "test";
+
+    // Act: Execute the code
+    const result = functionToTest(input);
+
+    // Assert: Verify the result
+    expect(result).toBe("expected output");
+  });
+
+  it("throws error for invalid input", () => {
+    // Test error scenarios
+    expect(() => functionToTest(null)).toThrow("Invalid input");
+  });
+
+  it("handles edge cases correctly", () => {
+    // Test boundary conditions
+    expect(functionToTest("")).toBe("");
+  });
+});
+```
+
+## Testing Patterns
+
+### Unit Testing (Functions/Classes)
+
+```typescript
+import { describe, expect, it } from "vitest";
+import { EmailValueObject } from "./email";
+
+describe("EmailValueObject", () => {
+  it("creates valid email", () => {
+    const email = new EmailValueObject("user@example.com");
+    expect(email.value).toBe("user@example.com");
+  });
+
+  it("rejects invalid email format", () => {
+    expect(() => new EmailValueObject("invalid")).toThrow(
+      "Invalid email format"
+    );
+  });
+
+  it("normalizes email to lowercase", () => {
+    const email = new EmailValueObject("USER@EXAMPLE.COM");
+    expect(email.value).toBe("user@example.com");
+  });
+});
+```
+
+### API Route Testing (Hono)
+
+```typescript
+import { describe, expect, it, vi } from "vitest";
+import { Hono } from "hono";
+
+describe("Contract: POST /users", () => {
+  it("creates user and returns 201", async () => {
+    const app = new Hono();
+    const createMock = vi.fn(async (data) => ({ id: "123", ...data }));
+
+    app.post("/users", async (c) => {
+      const body = await c.req.json();
+      const user = await createMock(body);
+      return c.json(user, 201);
+    });
+
+    const response = await app.request("/users", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ name: "John", email: "john@example.com" }),
+    });
+
+    expect(createMock).toHaveBeenCalledTimes(1);
+    expect(response.status).toBe(201);
+
+    const body = await response.json();
+    expect(body.id).toBe("123");
+    expect(body.name).toBe("John");
+  });
+
+  it("returns 400 for invalid data", async () => {
+    const app = new Hono();
+
+    app.post("/users", (c) => c.json({ error: "Bad Request" }, 400));
+
+    const response = await app.request("/users", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ invalid: "data" }),
+    });
+
+    expect(response.status).toBe(400);
+  });
+
+  it("requires authentication", async () => {
+    const app = new Hono();
+
+    app.post("/users", (c) => c.json({ error: "Unauthorized" }, 401));
+
+    const response = await app.request("/users", { method: "POST" });
+
+    expect(response.status).toBe(401);
+  });
+});
+```
+
+### Mocking Dependencies
+
+```typescript
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { UserService } from "./user-service";
+
+describe("UserService", () => {
+  let mockRepository: any;
+  let service: UserService;
+
+  beforeEach(() => {
+    // Create mock repository
+    mockRepository = {
+      findById: vi.fn(),
+      save: vi.fn(),
+      delete: vi.fn(),
+    };
+
+    service = new UserService(mockRepository);
+    vi.clearAllMocks();
+  });
+
+  it("fetches user by id", async () => {
+    // Setup mock return value
+    const mockUser = { id: "123", name: "John" };
+    mockRepository.findById.mockResolvedValue(mockUser);
+
+    // Execute
+    const result = await service.getUser("123");
+
+    // Verify
+    expect(mockRepository.findById).toHaveBeenCalledWith("123");
+    expect(result).toEqual(mockUser);
+  });
+
+  it("throws error when user not found", async () => {
+    mockRepository.findById.mockResolvedValue(null);
+
+    await expect(service.getUser("999")).rejects.toThrow("User not found");
+  });
+});
+```
+
+### Integration Testing
+
+```typescript
+import { describe, expect, it, beforeAll } from "vitest";
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { registerUserRoutes } from "./routes";
+
+describe("Integration: User Lifecycle", () => {
+  let app: OpenAPIHono;
+  let userId: string;
+
+  beforeAll(() => {
+    app = new OpenAPIHono();
+    registerUserRoutes(app);
+  });
+
+  it("complete user workflow: create → get → update → delete", async () => {
+    // Create
+    const createRes = await app.request("/users", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ name: "John", email: "john@example.com" }),
+    });
+    expect(createRes.status).toBe(201);
+    const created = await createRes.json();
+    userId = created.id;
+
+    // Get
+    const getRes = await app.request(`/users/${userId}`);
+    expect(getRes.status).toBe(200);
+
+    // Update
+    const updateRes = await app.request(`/users/${userId}`, {
+      method: "PUT",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ name: "John Updated" }),
+    });
+    expect(updateRes.status).toBe(200);
+
+    // Delete
+    const deleteRes = await app.request(`/users/${userId}`, {
+      method: "DELETE",
+    });
+    expect(deleteRes.status).toBe(200);
+  });
+});
+```
+
+## Playwright E2E Testing
+
+**When user needs E2E tests, use Playwright:**
+
+```typescript
+import { test, expect } from "@playwright/test";
+
+test.describe("User Authentication Flow", () => {
+  test("user can login successfully", async ({ page }) => {
+    await page.goto("http://localhost:3000/login");
+
+    await page.fill('input[name="email"]', "user@example.com");
+    await page.fill('input[name="password"]', "password123");
+    await page.click('button[type="submit"]');
+
+    await expect(page).toHaveURL("http://localhost:3000/dashboard");
+    await expect(page.locator("h1")).toContainText("Welcome");
+  });
+
+  test("shows error for invalid credentials", async ({ page }) => {
+    await page.goto("http://localhost:3000/login");
+
+    await page.fill('input[name="email"]', "wrong@example.com");
+    await page.fill('input[name="password"]', "wrongpass");
+    await page.click('button[type="submit"]');
+
+    await expect(page.locator(".error")).toContainText("Invalid credentials");
+  });
+});
+```
+
+## Biome Code Quality
+
+**For complete code quality setup, configuration, and quality gates workflow, see `quality-engineer` skill**
+
+**For basic code quality setup, provide:**
+
+1. **Biome Configuration**: Reference the template at `plugins/qa/templates/biome.json`
+2. **Scripts**: Add to package.json:
+
+```json
+{
+  "scripts": {
+    "format": "biome format --write . && bun run format:md && bun run format:pkg",
+    "format:md": "prettier --write '**/*.md' --log-level error",
+    "format:pkg": "prettier-package-json --write package.json --log-level error",
+    "lint": "biome check --write .",
+    "lint:fix": "biome check --write . --unsafe"
+  }
+}
+```
+
+3. **Pre-commit Hooks**: Recommend `husky` + `lint-staged` for automated checks
+
+## Test Commands
+
+**⚠️ CRITICAL: Always use `bun run test` NOT `bun test`**
+
+**Guide users to run tests properly:**
+
+```bash
+# From monorepo root - run all workspace tests
+bun run test run              # Single run all projects
+bun run test                  # Watch mode all projects
+bun run test run --coverage   # Coverage report (merged)
+bun run test --ui             # UI dashboard
+
+# From individual workspace
+cd apps/nexus
+bun run test run              # Single run this workspace only
+bun run test                  # Watch mode this workspace only
+bun run test run --coverage   # Coverage this workspace only
+
+# Via turbo (when configured)
+turbo run test                  # Run test script in all workspaces
+turbo run test --filter=nexus   # Run test in specific workspace
+
+# Run specific test file
+bun run test path/to/test.test.ts
+
+# Run Playwright E2E tests
+bunx playwright test
+```
+
+**Why `bun run test` not `bun test`?**
+
+- ✅ `bun run test` - Uses Vitest (correct)
+- ❌ `bun test` - Uses Bun's built-in test runner (wrong, no Vitest features)
+
+## Coverage Strategy
+
+**Provide guidance on test coverage:**
+
+1. **Critical Paths**: 100% coverage for:
+
+   - Authentication/authorization logic
+   - Payment processing
+   - Data validation
+   - Security-critical functions
+
+2. **Business Logic**: 80-90% coverage for:
+
+   - Domain models and services
+   - API routes and controllers
+   - Data transformations
+
+3. **UI Components**: 60-80% coverage for:
+
+   - User interactions
+   - Conditional rendering
+   - Error states
+
+4. **Don't Over-Test**:
+   - Skip trivial getters/setters
+   - Avoid testing framework code
+   - Focus on business value
+
+## Debugging Test Failures
+
+**When tests fail, systematically debug:**
+
+1. **Read Error Messages**: Understand what's failing
+2. **Check Mocks**: Verify mock setup and return values
+3. **Isolate**: Run single test to isolate issue
+4. **Add Logging**: Use `console.log()` to inspect values
+5. **Check Async**: Ensure proper `await` for async operations
+6. **Verify Setup**: Check beforeEach/afterEach hooks
+7. **Clean State**: Ensure tests don't share state
+
+## Vitest Configuration (Projects Mode for Monorepos)
+
+**Architecture: Root config orchestrates workspace tests**
+
+**Root config (`vitest.config.ts`):**
+
+```typescript
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    // Global test settings (can be overridden by workspaces)
+  },
+  projects: [
+    "./apps/nexus", // Backend workspace
+    "./apps/accessus", // Frontend workspace
+    // Add other workspaces...
+  ],
+});
+```
+
+**Workspace config (`apps/nexus/vitest.config.ts`):**
+
+```typescript
+import { defineProject } from "vitest/config";
+
+export default defineProject({
+  test: {
+    name: "nexus",
+    environment: "node",
+    globals: true,
+    setupFiles: ["./tests/setup.ts"],
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "lcov", "html"],
+      exclude: [
+        "coverage/**",
+        "dist/**",
+        "**/*.d.ts",
+        "**/*.config.ts",
+        "**/migrations/**",
+        "**/index.ts",
+      ],
+    },
+  },
+});
+```
+
+**Workspace package.json:**
+
+```json
+{
+  "scripts": {
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:watch": "vitest"
+  }
+}
+```
+
+## Critical Rules
+
+**NEVER:**
+
+- Use `any` type in tests - use proper typing
+- Skip error case testing
+- Write tests dependent on execution order
+- Test implementation details
+- Mock everything - test real integrations when possible
+- Ignore failing tests
+- Write tests without clear assertions
+- Use `bun test` command - use `bun run test` instead
+- Import from `bun:test` - use `vitest` instead
+
+**ALWAYS:**
+
+- Use `vitest` imports (NOT `bun:test` or jest)
+- Use `vi` for mocking (NOT `jest`)
+- Write descriptive test names
+- Test both happy paths and edge cases
+- Clean up test state (`vi.clearAllMocks()`, `vi.restoreAllMocks()`)
+- Use proper TypeScript types
+- Mock external dependencies (APIs, databases)
+- Test error scenarios and validation
+- Use `bun run test` command (NOT `bun test`)
+- Follow Arrange-Act-Assert pattern
+- Provide clear assertion messages
+- Use `defineProject()` for workspace configs
+
+## Deliverables
+
+When helping users, provide:
+
+1. **Complete Test Files**: Ready-to-run test code with proper imports
+2. **Test Helpers**: Reusable test utilities and builders
+3. **Mock Implementations**: Proper mock setup for dependencies
+4. **Test Commands**: Instructions for running tests
+5. **Coverage Guidance**: Recommendations for test coverage
+6. **Documentation**: Explanations of test strategy and patterns
+7. **E2E Test Suite**: Playwright tests for critical user flows (when applicable)
+8. **Biome Setup**: Configuration and scripts for code quality (when applicable)
+
+Remember: Good tests serve as documentation, catch bugs early, and give confidence to refactor. Write tests that provide value and are maintainable long-term.