qa-skills 3.0.0

package/skills/qa-diagram-generator/SKILL.md

@@ -0,0 +1,125 @@
+---
+name: qa-diagram-generator
+description: Universal diagram generator supporting 14 Mermaid diagram types. Works standalone or as an embedded service for other QA skills.
+output_dir: docs/diagrams
+---
+
+# QA Diagram Generator
+
+## Purpose
+
+Universal diagram generator for the QA skills ecosystem. Works in two modes:
+- **Standalone:** User directly asks for a diagram (e.g., "create a flowchart for the login test process")
+- **Embedded:** Other QA skills invoke this skill's patterns when they need visualizations
+
+## Trigger Phrases
+
+- "Draw a flowchart for [process/flow]"
+- "Create a sequence diagram for [API/auth flow]"
+- "Generate a Mermaid diagram from [description/screenshot]"
+- "Visualize the [test process/architecture/data model]"
+- "Diagram from screenshot" / "Create diagram from this image"
+- "State diagram for [bug lifecycle/test case states]"
+- "Gantt chart for [test schedule/sprint plan]"
+- "ER diagram for [test data model]"
+- "Mind map for [test coverage/feature decomposition]"
+- "C4 diagram for [system architecture]"
+- "User journey for [E2E scenario]"
+- "Pie chart / quadrant chart for [results/risk matrix]"
+
+## Dual-Use Pattern
+
+| Mode | Trigger | Output |
+|------|---------|--------|
+| **Standalone** | User: "Draw a sequence diagram for API auth flow" | Full Mermaid diagram + explanation |
+| **Embedded** | qa-spec-writer needs state diagram for spec | Reference `references/state-diagram.md` + generate inline |
+
+When embedded, the calling skill references the appropriate `references/*.md` file and generates Mermaid code following those patterns.
+
+## Input Sources
+
+- **Text description** — User or skill describes the flow/structure
+- **Screenshot/image analysis** — UI, architecture diagrams, whiteboards → appropriate diagram type
+- **Existing documentation** — Extract structure from specs, requirements, test plans
+- **Code analysis** — Infer from code structure (classes, flows, state machines)
+
+## Supported Diagram Types
+
+| Type | Use Cases | Mermaid Syntax | Reference |
+|------|-----------|----------------|-----------|
+| **Flowchart** | Test process flows, decision trees, regression flow | `flowchart` | `references/flowchart.md` |
+| **Sequence Diagram** | API interactions, login flow, test execution flow | `sequenceDiagram` | `references/sequence.md` |
+| **Class Diagram** | Test architecture, Page Object Model | `classDiagram` | `references/class-diagram.md` |
+| **State Diagram** | Bug lifecycle, test case states, user session states | `stateDiagram-v2` | `references/state-diagram.md` |
+| **ER Diagram** | Test data models, database schemas | `erDiagram` | `references/er-diagram.md` |
+| **Mind Map** | Test coverage mapping, feature decomposition | `mindmap` | `references/mindmap.md` |
+| **Gantt Chart** | Test schedules, sprint planning, release timelines | `gantt` | `references/gantt.md` |
+| **C4 Model** | System architecture (context/container/component) | `C4Context`, `C4Container`, `C4Component` | `references/c4-model.md` |
+| **User Journey** | User experience testing flows, E2E scenarios | `journey` | `references/journey.md` |
+| **Pie Chart** | Test result distribution, coverage breakdown | `pie` | `references/charts.md` |
+| **Quadrant Chart** | Risk matrix, priority vs effort, impact vs likelihood | `quadrantChart` | `references/charts.md` |
+| **Git Graph** | Branch strategy, release flow, merge workflows | `gitGraph` | `references/flowchart.md` (see note) |
+| **Block Diagram** | System components, data flow blocks | `block-beta` | `references/flowchart.md` |
+| **BPMN** | Business process flows, approval workflows | `bpmn` | `references/flowchart.md` |
+
+## Embedding Pattern for Other Skills
+
+When another skill needs a diagram, reference the appropriate file:
+
+| Visualization Need | Reference | Example |
+|--------------------|-----------|---------|
+| State machines, lifecycle | `references/state-diagram.md` | Bug lifecycle, test case states |
+| API flows, interactions | `references/sequence.md` | Login flow, API contract validation |
+| Decision logic, process flow | `references/flowchart.md` | Test process, regression flow |
+| Timelines, schedules | `references/gantt.md` | Sprint plan, release schedule |
+| Architecture layers | `references/c4-model.md` | System context, container diagram |
+| Test data structure | `references/er-diagram.md` | Test DB schema, fixture models |
+| Coverage/feature breakdown | `references/mindmap.md` | Test coverage map, feature tree |
+| User flows, E2E scenarios | `references/journey.md` | UAT journey, UX test flow |
+| Result distribution, risk | `references/charts.md` | Pass/fail pie, risk quadrant |
+| From screenshot/image | `references/from-screenshot.md` | UI → flowchart, whiteboard → diagram |
+
+## Workflow
+
+1. **Input:** Determine source (text, screenshot, doc, code)
+2. **Diagram type:** Select from 14 types based on content and purpose
+3. **Generate:** Produce valid Mermaid syntax per reference patterns
+4. **Output:** Markdown with fenced Mermaid block, ready for rendering
+
+## Scope
+
+**Can do (autonomous):**
+- Generate any of the 14 diagram types from description
+- Infer diagram type from content when not specified
+- Produce valid Mermaid syntax per reference guides
+- Support embedded invocation from other skills
+- Analyze screenshots/images to suggest diagram type and content
+
+**Cannot do (requires confirmation):**
+- Render diagrams (output is Mermaid source only)
+- Modify source documents or code
+- Choose diagram type that contradicts user intent
+
+**Will not do (out of scope):**
+- Non-Mermaid diagram formats (PlantUML, etc.) unless explicitly requested
+- Hand-drawn or raster image output
+
+## Quality Checklist
+
+- [ ] Diagram type matches content and purpose
+- [ ] Mermaid syntax is valid (no parse errors)
+- [ ] Labels and nodes are descriptive and QA-relevant
+- [ ] Diagram fits intended audience (technical vs business)
+- [ ] No sensitive data in labels
+- [ ] Reference file patterns followed when embedded
+
+## Troubleshooting
+
+| Symptom | Likely Cause | Fix |
+|---------|--------------|-----|
+| Mermaid parse error | Invalid syntax, reserved keywords | Check reference syntax; escape special chars |
+| Wrong diagram type | Ambiguous input | Ask user or infer from dominant structure (flow vs state vs sequence) |
+| Too complex | Too many nodes/edges | Split into multiple diagrams or simplify |
+| Embedded skill gets wrong ref | Mismatch between need and ref | Use embedding table to map visualization need → reference |
+| Screenshot analysis fails | Low quality or non-diagram image | Fall back to text description; ask user to describe |
+| C4/ER syntax errors | Mermaid version differences | Use standard syntax from references; avoid experimental features |

package/skills/qa-diagram-generator/references/c4-model.md

@@ -0,0 +1,53 @@
+# Mermaid C4 Model Syntax
+
+## Overview
+C4 diagrams show system architecture at Context, Container, and Component levels. Mermaid supports C4 via `C4Context`, `C4Container`, `C4Component` blocks.
+
+## Syntax
+```mermaid
+C4Context
+    title System Context
+    Person(user, "User")
+    System(system, "System")
+    Rel(user, system, "Uses")
+```
+
+## QA Examples
+
+### System Context
+```mermaid
+C4Context
+    title E-commerce System Context
+    Person(customer, "Customer")
+    System(ecom, "E-commerce Platform")
+    System(payment, "Payment Gateway")
+    Rel(customer, ecom, "Browses, Orders")
+    Rel(ecom, payment, "Processes payment")
+```
+
+### Container Diagram
+```mermaid
+C4Container
+    title API Test Target Architecture
+    Person(tester, "QA Engineer")
+    Container(api, "REST API", "Node.js")
+    Container(db, "Database", "PostgreSQL")
+    Rel(tester, api, "Tests")
+    Rel(api, db, "Reads/Writes")
+```
+
+### Component View
+```mermaid
+C4Component
+    title API Service Components
+    Container_Boundary(api, "API Service") {
+        Component(auth, "Auth", "JWT validation")
+        Component(handler, "Handlers", "Request routing")
+        Component(repo, "Repository", "Data access")
+    }
+```
+
+## When to Use
+- Test scope definition (what to test)
+- Integration test planning
+- Understanding system boundaries for E2E coverage

package/skills/qa-diagram-generator/references/charts.md

@@ -0,0 +1,58 @@
+# Mermaid Pie and Quadrant Charts
+
+## Overview
+- **Pie chart:** `pie` block with `title` and `"label" : value` pairs.
+- **Quadrant chart:** `quadrantChart` with `title`, `x-axis`, `y-axis`, and `quadrant` definitions.
+
+## Pie Chart Syntax
+```mermaid
+pie title Test Result Distribution
+    "Pass" : 85
+    "Fail" : 10
+    "Blocked" : 3
+    "Skip" : 2
+```
+
+## Quadrant Chart Syntax
+```mermaid
+quadrantChart
+    title Risk Matrix
+    x-axis Low Impact --> High Impact
+    y-axis Low Probability --> High Probability
+    quadrant-1 Monitor
+    quadrant-2 Mitigate
+    quadrant-3 Accept
+    quadrant-4 Transfer
+    "Feature A": [0.8, 0.6]
+    "Feature B": [0.3, 0.9]
+```
+
+## QA Examples
+
+### Test Results
+```mermaid
+pie title Sprint 24 Results
+    "Pass" : 142
+    "Fail" : 18
+    "Blocked" : 5
+    "Skip" : 3
+```
+
+### Risk Matrix
+```mermaid
+quadrantChart
+    title Test Risk Assessment
+    x-axis Low Impact --> High Impact
+    y-axis Low Likelihood --> High Likelihood
+    quadrant-1 Low priority
+    quadrant-2 High priority
+    quadrant-3 Monitor
+    quadrant-4 Critical
+    "Auth flow": [0.9, 0.8]
+    "Reports": [0.4, 0.3]
+```
+
+## When to Use
+- Test result distribution, coverage breakdown
+- Risk prioritization, defect severity mapping
+- Stakeholder reporting visuals

package/skills/qa-diagram-generator/references/class-diagram.md

@@ -0,0 +1,85 @@
+# Mermaid Class Diagram Syntax — QA Use Cases
+
+## Syntax Overview
+
+Class diagrams use `classDiagram`. Classes: `class ClassName { +field +method() }`. Relationships: `-->` (association), `--|>` (inheritance), `*--` (composition), `o--` (aggregation). Visibility: `+` public, `-` private, `#` protected.
+
+```mermaid
+classDiagram
+    class TestCase {
+        +string id
+        +string title
+        +run() Result
+    }
+    TestCase --> Assertion : uses
+```
+
+## Example 1: Test Architecture
+
+```mermaid
+classDiagram
+    class TestRunner {
+        +run(suite) Results
+        +stop()
+    }
+    class TestSuite {
+        +List~TestCase~ tests
+        +add(TestCase)
+    }
+    class TestCase {
+        +string id
+        +run() Result
+    }
+    TestRunner --> TestSuite : executes
+    TestSuite *-- TestCase : contains
+```
+
+## Example 2: Page Object Model
+
+```mermaid
+classDiagram
+    class BasePage {
+        #WebDriver driver
+        +visit(url)
+        +find(locator)
+    }
+    class LoginPage {
+        +usernameInput
+        +passwordInput
+        +loginButton
+        +login(user, pass)
+    }
+    class DashboardPage {
+        +welcomeMessage
+        +logout()
+    }
+    BasePage <|-- LoginPage
+    BasePage <|-- DashboardPage
+```
+
+## Example 3: Test Data Model
+
+```mermaid
+classDiagram
+    class TestResult {
+        +string status
+        +number duration
+        +string error
+    }
+    class TestCase {
+        +string id
+        +run() TestResult
+    }
+    class Report {
+        +List~TestResult~ results
+        +generate() HTML
+    }
+    TestCase --> TestResult : produces
+    Report *-- TestResult : aggregates
+```
+
+## When to Use
+
+- **Test architecture:** Runner, suite, case hierarchy
+- **Page Object Model:** Base page, page classes
+- **Test data models:** Result, report, fixture structures

package/skills/qa-diagram-generator/references/er-diagram.md

@@ -0,0 +1,69 @@
+# Mermaid ER Diagram Syntax — QA Use Cases
+
+## Syntax Overview
+
+ER diagrams use `erDiagram`. Entities: `ENTITY { type attribute PK }`. Relationships: `ENTITY1 ||--o{ ENTITY2 : "relationship"`. Cardinality: `||--||` one-to-one, `||--o{` one-to-many, `}o--o{` many-to-many.
+
+```mermaid
+erDiagram
+    USER ||--o{ ORDER : places
+    ORDER ||--|{ ITEM : contains
+    USER {
+        string id PK
+        string name
+    }
+```
+
+## Example 1: Test Data Model
+
+```mermaid
+erDiagram
+    TEST_SUITE ||--o{ TEST_CASE : contains
+    TEST_CASE ||--o{ TEST_RUN : produces
+    TEST_RUN {
+        string id PK
+        string status
+        datetime executed_at
+    }
+    TEST_CASE {
+        string id PK
+        string title
+        string steps
+    }
+```
+
+## Example 2: Bug–Test Traceability
+
+```mermaid
+erDiagram
+    REQUIREMENT ||--o{ TEST_CASE : validates
+    TEST_CASE ||--o{ BUG : reveals
+    BUG ||--o| REQUIREMENT : relates_to
+    REQUIREMENT {
+        string id PK
+        string title
+    }
+    BUG {
+        string id PK
+        string status
+    }
+```
+
+## Example 3: Test Environment Model
+
+```mermaid
+erDiagram
+    ENVIRONMENT ||--o{ TEST_RUN : hosts
+    TEST_RUN }o--|| TEST_SUITE : belongs_to
+    ENVIRONMENT {
+        string id PK
+        string name
+        string url
+    }
+```
+
+## When to Use
+
+- **Test data models:** Suite, case, run relationships
+- **Traceability:** Requirement ↔ Test Case ↔ Bug
+- **Environment/config:** Environment, run, suite links

package/skills/qa-diagram-generator/references/flowchart.md

@@ -0,0 +1,92 @@
+# Mermaid Flowchart Syntax — QA Use Cases
+
+## Syntax Overview
+
+Flowcharts use `flowchart` or `graph` keyword. Direction: `TB` (top-bottom), `LR` (left-right), `RL`, `BT`. Nodes: `[rect]`, `(rounded)`, `{diamond}`, `[(database)]`, `[[subroutine]]`. Edges: `-->`, `---`, `-.->`, `==>`.
+
+```mermaid
+flowchart LR
+    A[Start] --> B{Decision}
+    B -->|Yes| C[Action]
+    B -->|No| D[End]
+```
+
+## Example 1: Test Process Flow
+
+```mermaid
+flowchart TB
+    subgraph Input
+        R[Requirements]
+        S[Specs]
+    end
+    R --> TC[Test Case Design]
+    S --> TC
+    TC --> EX[Execute Tests]
+    EX --> RPT{Pass?}
+    RPT -->|Yes| DONE[Done]
+    RPT -->|No| BUG[Log Bug]
+    BUG --> FIX[Dev Fix]
+    FIX --> EX
+```
+
+## Example 2: Regression Decision Tree
+
+```mermaid
+flowchart LR
+    CHG[Code Change] --> AFFECT{Affected Area?}
+    AFFECT -->|Core| FULL[Full Regression]
+    AFFECT -->|Module X| MOD[Module X Suite]
+    AFFECT -->|Config Only| SMOKE[Smoke Only]
+```
+
+## Example 3: Test Execution Flow
+
+```mermaid
+flowchart TB
+    START[CI Trigger] --> UNIT[Unit Tests]
+    UNIT --> INT[Integration Tests]
+    INT --> E2E[E2E Tests]
+    E2E --> REPORT[Report]
+    REPORT --> GATE{All Pass?}
+    GATE -->|Yes| DEPLOY[Deploy]
+    GATE -->|No| BLOCK[Block Pipeline]
+```
+
+## Related: Git Graph, Block Diagram, BPMN
+
+**Git Graph** — Branch strategy, release flow:
+```mermaid
+gitGraph
+  commit
+  branch develop
+  checkout develop
+  commit
+  checkout main
+  merge develop
+```
+
+**Block Diagram** (`block-beta`) — System components:
+```mermaid
+block-beta
+  columns 2
+  block:core["API + DB"]
+  block:qa["Tests"]
+```
+
+**BPMN** — Approval workflows:
+```mermaid
+bpmn
+  task(Submit)
+  task(Review)
+  task(Approve)
+  Submit --> Review --> Approve
+```
+
+## When to Use
+
+- **Test process flows:** End-to-end QA workflow
+- **Decision trees:** Regression scope, test selection logic
+- **Pipeline flows:** CI/CD test stages, gates
+- **Git Graph:** Release flow, branch strategy
+- **Block Diagram:** System component layout
+- **BPMN:** Approval workflows, business process testing

package/skills/qa-diagram-generator/references/from-screenshot.md

@@ -0,0 +1,45 @@
+# Diagram Generation from Screenshots/Images
+
+## Overview
+When the user provides a screenshot or image, analyze it to infer structure and generate an appropriate Mermaid diagram. Use vision capabilities to extract UI layout, flow, or relationships.
+
+## Analysis Steps
+
+1. **Identify diagram type:** UI flow → flowchart/sequence; form layout → class/ER; state transitions → state diagram; timeline → Gantt.
+2. **Extract elements:** Buttons, fields, steps, screens, entities.
+3. **Map relationships:** Navigation, data flow, dependencies.
+4. **Generate Mermaid:** Use the matching reference (flowchart, sequence, etc.).
+
+## Input Types
+
+| Image Content | Diagram Type | Reference |
+| ------------- | ------------ | --------- |
+| Multi-step wizard, form flow | Flowchart | flowchart.md |
+| Login/auth screens | Sequence | sequence.md |
+| Form with fields, entities | Class/ER | class-diagram.md, er-diagram.md |
+| Status badges, lifecycle | State | state-diagram.md |
+| Dashboard with charts | Pie/Quadrant | charts.md |
+| Calendar, timeline view | Gantt | gantt.md |
+
+## Example: Login Screen → Sequence
+Given a login screenshot with email, password, submit:
+- Actors: User, Browser, API
+- Steps: Enter credentials → Submit → Validate → Redirect
+- Output: `references/sequence.md` pattern
+
+## Example: Multi-Step Form → Flowchart
+Given screenshots of Step 1 → Step 2 → Step 3:
+- Nodes: Each step
+- Edges: Next/Back/Submit
+- Output: `references/flowchart.md` pattern
+
+## When to Use
+- User provides screenshot instead of text description
+- Reverse-engineering UI flows for test design
+- Documenting existing interfaces from visuals
+
+## Limitations
+Low-resolution or hand-drawn images may require user clarification. Fall back to asking for a text description when structure cannot be reliably inferred.
+
+## Limitations
+Low-resolution or hand-drawn images may require user clarification. Fall back to asking for a text description when structure cannot be reliably inferred.

package/skills/qa-diagram-generator/references/gantt.md

@@ -0,0 +1,49 @@
+# Mermaid Gantt Chart Syntax
+
+## Overview
+Gantt charts show tasks over time. Use `gantt` block with `title`, `dateFormat`, and task definitions. Tasks use `section`, `task name :crit, id, start, end`.
+
+## Syntax
+```mermaid
+gantt
+    title Example
+    dateFormat YYYY-MM-DD
+    section Phase 1
+    Task A :a1, 2024-01-01, 7d
+    Task B :a2, after a1, 5d
+    section Phase 2
+    Task C :crit, 2024-01-15, 3d
+```
+
+## QA Examples
+
+### Test Schedule
+```mermaid
+gantt
+    title Sprint 24 Test Schedule
+    dateFormat YYYY-MM-DD
+    section Unit Tests
+    Unit test execution :ut, 2024-03-01, 3d
+    section Integration
+    API integration tests :api, after ut, 2d
+    section E2E
+    E2E regression :crit, e2e, after api, 4d
+```
+
+### Release Test Plan
+```mermaid
+gantt
+    title Release 2.0 Test Phases
+    dateFormat YYYY-MM-DD
+    section Smoke
+    Smoke tests :s1, 2024-03-10, 1d
+    section Regression
+    Full regression :crit, r1, after s1, 5d
+    section UAT
+    UAT window :u1, after r1, 3d
+```
+
+## When to Use
+- Test schedules, sprint planning, release timelines
+- Phase dependencies and critical path
+- Resource allocation over time

package/skills/qa-diagram-generator/references/journey.md

@@ -0,0 +1,50 @@
+# Mermaid User Journey Syntax
+
+## Overview
+User journeys map user actions and experiences over time. Use `journey` block with `title` and `section` for phases. Tasks use `Task name: score: participant`.
+
+## Syntax
+```mermaid
+journey
+    title User Journey
+    section Phase 1
+      Action 1: 5: User
+      Action 2: 3: System
+    section Phase 2
+      Action 3: 5: User
+```
+
+## QA Examples
+
+### Login Flow UX
+```mermaid
+journey
+    title Login User Journey
+    section Enter
+      Open login page: 5: User
+      Enter credentials: 4: User
+    section Validate
+      Submit form: 5: User
+      Validate & redirect: 3: System
+    section Success
+      Land on dashboard: 5: User
+```
+
+### Checkout Flow
+```mermaid
+journey
+    title Checkout Experience
+    section Cart
+      Add items: 5: Customer
+      Review cart: 4: Customer
+    section Payment
+      Enter payment: 3: Customer
+      Confirm order: 5: Customer
+    section Confirmation
+      Receive confirmation: 5: Customer
+```
+
+## When to Use
+- UAT scenario design
+- UX testing flows
+- Identifying pain points (low scores) for test focus

package/skills/qa-diagram-generator/references/mindmap.md

@@ -0,0 +1,75 @@
+# Mermaid Mind Map Syntax — QA Use Cases
+
+## Syntax Overview
+
+Mind maps use `mindmap`. Root: `root((Topic))`. Children: indented with `()` for nodes. Use `:` for multiple children. Supports `[]` and `(())` for styling.
+
+```mermaid
+mindmap
+  root((Topic))
+    Branch A
+    Branch B
+      Sub 1
+      Sub 2
+```
+
+## Example 1: Test Coverage Mapping
+
+```mermaid
+mindmap
+  root((Test Coverage))
+    Unit
+      Services
+      Utils
+      Models
+    Integration
+      API
+      DB
+    E2E
+      Critical Paths
+      Happy Paths
+    Accessibility
+      WCAG
+      Screen Reader
+```
+
+## Example 2: Feature Decomposition
+
+```mermaid
+mindmap
+  root((Checkout Feature))
+    Cart
+      Add item
+      Remove item
+      Update qty
+    Payment
+      Card
+      PayPal
+      Wallet
+    Shipping
+      Address
+      Options
+      Tracking
+```
+
+## Example 3: Risk Areas
+
+```mermaid
+mindmap
+  root((Test Risks))
+    High
+      Payment flows
+      Auth
+    Medium
+      Search
+      Filters
+    Low
+      Static pages
+      Help
+```
+
+## When to Use
+
+- **Test coverage mapping:** Areas to cover, hierarchy
+- **Feature decomposition:** Modules, sub-features
+- **Risk/priority mapping:** High/medium/low areas