@smartsoft001/pro-claude-plugins 0.2.0

package/plugins/flow/skills/review/SKILL.md

@@ -0,0 +1,443 @@
+---
+name: review
+description: Run parallel multi-dimensional code review using Agent Teams. Spawns specialized reviewers for quality, tests, security, and accessibility/performance.
+allowed-tools:
+  - Bash
+  - Read
+  - Glob
+  - Grep
+  - Task
+  - TaskCreate
+  - TaskUpdate
+  - TaskList
+  - TaskGet
+  - AskUserQuestion
+  - mcp__linear__get_issue
+  - mcp__linear__list_comments
+  - mcp__linear__save_comment
+---
+
+# Review Skill
+
+Run parallel multi-dimensional code review using Agent Teams. Spawns specialized reviewers for quality, tests, security, and accessibility/performance.
+
+## Execution Checklist
+
+Execute each step in order. Do not skip any step marked as MANDATORY.
+
+- [ ] **1. Determine review scope** — analyze git diff for changed files + affected projects
+- [ ] **2. Check team prerequisites** — verify `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`
+- [ ] **3. Create Review Board team** — spawn 4 specialized reviewer teammates
+- [ ] **4. Monitor reviews** — track task completions, handle questions between reviewers
+- [ ] **5. Synthesize findings** — delegate to `shared-report-synthesizer`
+- [ ] **6. Post to Linear** — create single review comment in Polish
+- [ ] **7. Present to user** — show findings with severity ratings
+- [ ] **8. Cleanup team**
+
+### Task Progress Tracking
+
+**MANDATORY**: Use Claude Code's built-in task tracking to provide real-time progress visibility.
+
+**Task naming convention**: Every task subject MUST be prefixed with the Linear task ID (or scope):
+
+```
+[REVIEW] <linearTaskId> <step description>
+```
+
+**At skill start**: Create tasks for each review dimension:
+
+```
+TaskCreate({
+  subject: "[REVIEW] MM-123 Quality review",
+  description: "Lint, type-check, code style, import ordering",
+  activeForm: "[REVIEW] MM-123 Running quality review"
+})
+```
+
+## Role
+
+**You are an experienced code review lead** with:
+
+- Over 10 years of reviewing production code
+- Deep knowledge of TypeScript, Angular, NestJS security patterns
+- WCAG 2.1 accessibility expertise
+- Performance optimization and bundle analysis skills
+- Ability to coordinate multiple review perspectives
+
+You produce reviews that are:
+
+- **Thorough**: covering quality, tests, security, and accessibility
+- **Actionable**: each finding has a clear severity and fix recommendation
+- **Balanced**: acknowledging good patterns alongside issues
+- **Prioritized**: critical issues first, minor suggestions last
+
+## Usage
+
+```
+/review [linearTaskId]        # Review changes for a Linear task
+/review --staged              # Review all staged changes
+/review --diff=main           # Review diff against main branch
+```
+
+## Parameters
+
+- `linearTaskId` - Linear task ID (e.g., ENG-123)
+- `--staged` - Review all staged changes (no Linear task required)
+- `--diff=<branch>` - Review diff against specified branch
+
+## Instructions
+
+### Step 1: Determine Review Scope
+
+Analyze the changes to review:
+
+**If `linearTaskId` provided:**
+
+1. Fetch task from Linear via MCP
+2. Find related branch/commits via `git log --all --grep="<taskId>"`
+3. Determine changed files via `git diff main...<branch>`
+
+**If `--staged` provided:**
+
+1. Use `git diff --cached --name-only` to find staged files
+2. Use `git diff --cached` for full diff
+
+**If `--diff=<branch>` provided:**
+
+1. Use `git diff <branch>...HEAD --name-only` for changed files
+2. Use `git diff <branch>...HEAD` for full diff
+
+**Extract:**
+
+- List of changed files with change type (added/modified/deleted)
+- Affected Nx projects (from file paths)
+- Change statistics (lines added/removed per file)
+
+### Step 2: Check Team Prerequisites
+
+**Check `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`**:
+
+If env var is NOT set:
+
+→ Fall back to sequential review using `shared-verification-orchestrator` agent.
+
+```
+Tryb zespołowy niedostępny — brak CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1.
+Uruchamiam sekwencyjną weryfikację...
+```
+
+Run the `shared-verification-orchestrator` pipeline and present results. Stop here.
+
+**If env var IS set** → Continue to Step 3.
+
+### Step 3: Create Review Board Team
+
+Create 4 specialized reviewer tasks and spawn teammates:
+
+#### Reviewer 1: Quality Reviewer
+
+```
+TaskCreate({
+  subject: "[REVIEW] <taskId> Quality review: lint and type-check",
+  description: "Check lint errors, TypeScript type safety, code style, import ordering",
+  activeForm: "[REVIEW] <taskId> Running quality review"
+})
+```
+
+**Spawn prompt:**
+
+```
+You are the Quality Reviewer in a Review Board for [scope description].
+
+Changed files:
+[list of changed files with diffs]
+
+YOUR FOCUS:
+- Run linting: `nx lint [project]` for each affected project
+- Run type-check: `npx tsc --noEmit` for affected projects
+- Check code style: naming conventions, function length, complexity
+- Verify import ordering matches ESLint rules
+- Check for unused imports, dead code, TODO comments
+- Verify Angular modern APIs (signals, @if/@for, inject())
+
+DELEGATE TO existing agents as needed:
+- `shared-style-enforcer` for detailed style analysis
+- `shared-verification-runner` for running lint/type-check commands
+
+OUTPUT FORMAT:
+## Quality Review Report
+
+### Critical Issues
+- [issue] — severity: CRITICAL — file: path/to/file.ts:line
+
+### Warnings
+- [warning] — severity: MEDIUM — file: path/to/file.ts:line
+
+### Passed Checks
+- [x] Check passed
+
+### Summary
+Issues found: X critical, Y medium, Z low
+Recommendation: PASS / PASS_WITH_WARNINGS / BLOCK
+```
+
+#### Reviewer 2: Test Reviewer
+
+```
+TaskCreate({
+  subject: "[REVIEW] <taskId> Test review: coverage and quality",
+  description: "Unit test coverage, test quality, AAA pattern compliance",
+  activeForm: "[REVIEW] <taskId> Running test review"
+})
+```
+
+**Spawn prompt:**
+
+```
+You are the Test Reviewer in a Review Board for [scope description].
+
+Changed files:
+[list of changed files with diffs]
+
+YOUR FOCUS:
+- Run unit tests: `nx test [project] --coverage` for affected projects
+- Check coverage meets 90% minimum for new code
+- Verify AAA pattern (Arrange-Act-Assert) in all test files
+- Check test naming: describe('@smartsoft001/pro-...'), it('should...')
+- Verify mock patterns match project conventions
+- Check for missing edge case tests
+- Verify no skipped tests (xit, xdescribe)
+
+DELEGATE TO existing agents as needed:
+- `shared-coverage-enforcer` for coverage analysis
+- `shared-test-runner` for test execution
+
+OUTPUT FORMAT:
+## Test Review Report
+
+### Critical Issues
+- [issue] — severity: CRITICAL — file: path/to/file.spec.ts:line
+
+### Warnings
+- [warning] — severity: MEDIUM — file: path/to/file.spec.ts:line
+
+### Coverage Report
+| Project | Coverage | Required | Status |
+| --- | --- | --- | --- |
+| [project] | 85% | 90% | ❌ BELOW |
+
+### Passed Checks
+- [x] Check passed
+
+### Summary
+Issues found: X critical, Y medium, Z low
+Recommendation: PASS / PASS_WITH_WARNINGS / BLOCK
+```
+
+#### Reviewer 3: Security Reviewer
+
+```
+TaskCreate({
+  subject: "[REVIEW] <taskId> Security review: OWASP and deps",
+  description: "OWASP top 10, dependency audit, secrets detection",
+  activeForm: "[REVIEW] <taskId> Running security review"
+})
+```
+
+**Spawn prompt:**
+
+```
+You are the Security Reviewer in a Review Board for [scope description].
+
+Changed files:
+[list of changed files with diffs]
+
+YOUR FOCUS:
+- Check for OWASP Top 10 vulnerabilities in changed code:
+  - XSS (innerHTML, bypassSecurityTrust*, template injection)
+  - SQL/NoSQL injection (unsanitized query parameters)
+  - Broken authentication (token handling, session management)
+  - Sensitive data exposure (logging secrets, hardcoded credentials)
+  - CSRF protection
+- Run dependency audit: `npm audit --audit-level=moderate`
+- Check for hardcoded secrets, API keys, tokens
+- Verify input validation at system boundaries
+- Check for insecure HTTP calls (http:// vs https://)
+- Review authorization checks in backend code
+
+DELEGATE TO existing agents as needed:
+- `shared-security-scanner` for automated security scanning
+
+OUTPUT FORMAT:
+## Security Review Report
+
+### Critical Issues
+- [issue] — severity: CRITICAL — file: path/to/file.ts:line — OWASP: [category]
+
+### Warnings
+- [warning] — severity: MEDIUM — file: path/to/file.ts:line
+
+### Dependency Audit
+- Vulnerabilities found: [count by severity]
+
+### Passed Checks
+- [x] Check passed
+
+### Summary
+Issues found: X critical, Y medium, Z low
+Recommendation: PASS / PASS_WITH_WARNINGS / BLOCK
+```
+
+#### Reviewer 4: A11y + Performance Reviewer
+
+```
+TaskCreate({
+  subject: "[REVIEW] <taskId> A11y + Performance review",
+  description: "WCAG 2.1 accessibility, bundle sizes, performance patterns",
+  activeForm: "[REVIEW] <taskId> Running a11y + performance review"
+})
+```
+
+**Spawn prompt:**
+
+```
+You are the Accessibility & Performance Reviewer in a Review Board for [scope description].
+
+Changed files:
+[list of changed files with diffs]
+
+YOUR FOCUS (Accessibility):
+- WCAG 2.1 compliance in templates:
+  - Alt text for images
+  - ARIA labels for interactive elements
+  - Keyboard navigation support
+  - Color contrast (check Tailwind classes)
+  - Focus management
+  - Semantic HTML usage
+- Screen reader compatibility
+
+YOUR FOCUS (Performance):
+- Bundle size impact (new imports, lazy loading)
+- Change detection optimization (OnPush, signals)
+- Template performance (trackBy/@for track, computed signals)
+- Memory leaks (unsubscribed observables, event listeners)
+- Unnecessary re-renders
+
+DELEGATE TO existing agents as needed:
+- `ui-a11y-validator` for accessibility scanning
+- `shared-performance-validator` for performance analysis
+
+OUTPUT FORMAT:
+## A11y + Performance Review Report
+
+### Critical Issues
+- [issue] — severity: CRITICAL — file: path/to/file.ts:line — type: A11Y/PERF
+
+### Warnings
+- [warning] — severity: MEDIUM — file: path/to/file.ts:line
+
+### Accessibility Audit
+- WCAG violations: [count]
+- Missing ARIA labels: [count]
+
+### Performance Impact
+- New dependencies added: [list]
+- Bundle size estimate: [impact]
+
+### Passed Checks
+- [x] Check passed
+
+### Summary
+Issues found: X critical, Y medium, Z low
+Recommendation: PASS / PASS_WITH_WARNINGS / BLOCK
+```
+
+### Step 4: Monitor Reviews
+
+While teammates are working:
+
+1. **Track progress** via `TaskList` — check which reviewers have completed
+2. **Handle cross-reviewer communication**:
+   - When a reviewer finishes with CRITICAL or HIGH findings, broadcast to other reviewers
+   - Example: Security reviewer finds XSS → notify Quality reviewer to check sanitization
+3. **Wait for all reviewers** to complete (or timeout after reasonable period)
+
+**Cross-reviewer broadcast logic:**
+
+```
+When reviewer finishes:
+  IF findings contain CRITICAL or HIGH severity:
+    FOR each other active reviewer:
+      Send broadcast: "[Reviewer] found [severity] issue: [summary]"
+      Ask them to check related areas
+```
+
+### Step 5: Synthesize Findings
+
+After all 4 reviewers complete:
+
+1. **Collect all reports** from reviewer tasks
+2. **Delegate to `shared-report-synthesizer`** with:
+   - Team type: REVIEW
+   - All 4 reviewer reports
+   - Linear task ID (if available)
+
+The synthesizer will:
+
+- Merge findings by category
+- Deduplicate identical issues
+- Flag conflicts between reviewers
+- Produce single Polish-language report
+
+### Step 6: Post to Linear
+
+**If `linearTaskId` was provided:**
+
+Post the synthesized review report as a comment on the Linear task via MCP.
+
+**If `--staged` or `--diff`:**
+
+Skip Linear posting (no task to attach to).
+
+### Step 7: Present to User
+
+Show the synthesized review results to the user:
+
+1. **Overall verdict**: PASS / PASS_WITH_WARNINGS / BLOCK
+2. **Summary table** with per-dimension results
+3. **Critical issues** requiring immediate attention
+4. **Warnings** for consideration
+5. **Passed checks** for confidence
+
+### Step 8: Cleanup Team
+
+Mark all review tasks as completed and clean up team resources.
+
+## Fallback: Sequential Review
+
+When `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` is NOT set, run a sequential review:
+
+1. Delegate to `shared-verification-orchestrator` for the full 5-stage pipeline
+2. Present results to user
+3. Post to Linear if task ID provided
+
+This provides the same verification coverage, just without the parallelism and specialization.
+
+## Guidelines
+
+1. **All Linear comments in Polish** — review reports posted to Linear must be in Polish
+2. **User-facing output can be in user's language** — terminal output matches user's language
+3. **Severity ratings are mandatory** — every finding must have CRITICAL/HIGH/MEDIUM/LOW
+4. **Recommendations must be actionable** — don't just flag issues, suggest fixes
+5. **Respect existing patterns** — don't flag patterns that are established conventions
+6. **Consider context** — new code vs modified code may have different standards
+7. **Be constructive** — balance criticism with positive observations
+8. **Track everything** — use TaskCreate/TaskUpdate for visibility into review progress
+
+## Agent Team Mode (Experimental)
+
+**Prerequisite**: `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` in settings.
+
+**Activation**: Automatic when env var is set.
+
+**Fallback**: If env var not set, skill runs in standard sequential mode via `shared-verification-orchestrator`.

package/plugins/flow/skills/test-e2e/SKILL.md

@@ -0,0 +1,164 @@
+---
+name: test-e2e
+description: Orchestrate E2E Playwright test creation — scaffold project, inject data-testid attributes, write Page Objects and test specs, and run tests.
+allowed-tools:
+  - Bash
+  - Read
+  - Write
+  - Edit
+  - Glob
+  - Grep
+  - Task
+---
+
+# E2E Test Skill
+
+Orchestrate the full E2E Playwright testing workflow: ensure project infrastructure exists, inject `data-testid` attributes into changed component templates, write Page Objects and test specs, and run tests.
+
+## Usage
+
+```
+/test-e2e [component-paths or 'changed']
+```
+
+### Parameters
+
+- **component-paths**: Explicit paths to component files (e.g., `libs/shared/angular/src/lib/components/contact-form/contact-form.component.ts`)
+- **`changed`**: Automatically detect changed component templates from `git diff`
+
+## Workflow
+
+Execute each step in order:
+
+### Step 1: Identify Target Components
+
+**If `changed` is specified:**
+
+```bash
+# Find changed component templates
+git diff --name-only HEAD | grep -E "\.component\.(html|ts)$"
+```
+
+**If explicit paths are provided:**
+
+Use the provided paths directly.
+
+**Output:** List of component files to process.
+
+### Step 2: Scaffold E2E Project
+
+**Delegate to `e2e-project-scaffolder` agent:**
+
+```
+Check if E2E Playwright project exists for the target application.
+If not, scaffold one with Nx generator, multi-browser config, and base Page Object.
+```
+
+The agent will:
+
+1. Check for existing E2E project (idempotent)
+2. Scaffold if missing: Playwright config, directory structure, base page
+3. Report status
+
+**If project already exists:** Continue to Step 3.
+**If scaffolded:** Continue to Step 3.
+
+### Step 3: Inject `data-testid` Attributes
+
+**Delegate to `e2e-data-testid-injector` agent:**
+
+```
+Scan the following changed component templates and inject data-testid attributes:
+
+Components:
+- [list of component files from Step 1]
+
+Rules:
+- Naming convention: {component-name}-{element-type}-{identifier}
+- Target interactive elements only
+- NEVER overwrite existing data-testid attributes
+- Preserve template formatting
+```
+
+The agent will:
+
+1. Read each component template
+2. Identify interactive elements without `data-testid`
+3. Inject attributes following naming convention
+4. Report injection summary
+
+### Step 4: Write E2E Tests
+
+**Delegate to `e2e-test-writer` agent:**
+
+```
+Write Playwright E2E tests for the following components:
+
+Components:
+- [list of component files from Step 1]
+
+E2E project location: [path from Step 2]
+
+Requirements:
+- Create Page Object per component extending BasePage
+- Create test spec per component
+- Use data-testid selectors exclusively
+- Cover: visibility, interactions, form submissions, navigation, error states
+- Use Playwright auto-waiting (no manual sleeps)
+- Cross-reference all selectors against template data-testid values
+```
+
+The agent will:
+
+1. Read component `.ts` and `.html` files
+2. Create Page Objects in `e2e/src/pages/`
+3. Create test specs in `e2e/src/specs/`
+4. Cross-reference selectors against templates
+
+### Step 5: Run E2E Tests
+
+```bash
+# Run E2E tests
+npx nx e2e {app-name}-e2e
+```
+
+**If tests pass:** Report success.
+**If tests fail:** Analyze failures and fix — delegate back to `e2e-test-writer` if needed.
+
+### Step 6: Report Results
+
+Generate a summary report:
+
+```markdown
+## E2E Test Report
+
+### Components Processed
+
+| Component            | Testids Injected | Tests Written | Status |
+| -------------------- | ---------------- | ------------- | ------ |
+| ContactFormComponent | 5                | 6             | PASS   |
+| ArticleListComponent | 3                | 4             | PASS   |
+
+### Summary
+
+- **E2E Project**: [existed / scaffolded]
+- **Testids injected**: [total count]
+- **Tests created**: [total count]
+- **Test execution**: [PASS / FAIL with details]
+
+### Files Modified
+
+| File                                 | Change                         |
+| ------------------------------------ | ------------------------------ |
+| `contact-form.component.html`        | Added 5 data-testid attributes |
+| `e2e/src/pages/contact-form.page.ts` | New Page Object                |
+| `e2e/src/specs/contact-form.spec.ts` | New test spec (6 tests)        |
+```
+
+## Rules
+
+1. **Always scaffold first** — ensure E2E project exists before writing tests
+2. **Always inject testids first** — ensure selectors exist before writing Page Objects
+3. **Use agents for specialized work** — delegate to the right agent for each step
+4. **Run tests after writing** — verify tests pass before reporting success
+5. **Report comprehensively** — include injection summary, tests created, and execution status