qa-skills 3.0.0 → 3.1.0

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

@@ -1,125 +0,0 @@
----
-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

@@ -1,53 +0,0 @@
-# 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

@@ -1,58 +0,0 @@
-# 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

@@ -1,85 +0,0 @@
-# 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

@@ -1,69 +0,0 @@
-# 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

@@ -1,92 +0,0 @@
-# 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

@@ -1,45 +0,0 @@
-# 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

@@ -1,49 +0,0 @@
-# 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

@@ -1,50 +0,0 @@
-# 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

@@ -1,75 +0,0 @@
-# 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