qa-skills 3.0.0

package/skills/qa-k6-writer/references/patterns.md

@@ -0,0 +1,304 @@
+# k6 Patterns Reference
+
+## Load Profiles
+
+### Load Testing (Steady Load)
+Gradual ramp-up, sustained load, gradual ramp-down.
+
+```javascript
+export const options = {
+  stages: [
+    { duration: '2m', target: 50 },
+    { duration: '5m', target: 50 },
+    { duration: '2m', target: 0 },
+  ],
+};
+```
+
+### Stress Testing (Beyond Capacity)
+Increase load until system breaks; identify breaking point.
+
+```javascript
+export const options = {
+  stages: [
+    { duration: '2m', target: 100 },
+    { duration: '5m', target: 100 },
+    { duration: '2m', target: 200 },
+    { duration: '5m', target: 200 },
+    { duration: '2m', target: 300 },
+    { duration: '5m', target: 300 },
+    { duration: '2m', target: 0 },
+  ],
+};
+```
+
+### Soak Testing (Endurance)
+Sustained load over extended period to find memory leaks, degradation.
+
+```javascript
+export const options = {
+  stages: [
+    { duration: '5m', target: 50 },
+    { duration: '2h', target: 50 },
+    { duration: '5m', target: 0 },
+  ],
+};
+```
+
+### Spike Testing (Sudden Burst)
+Rapid spike to simulate traffic surge.
+
+```javascript
+export const options = {
+  stages: [
+    { duration: '10s', target: 0 },
+    { duration: '1m', target: 500 },
+    { duration: '3m', target: 500 },
+    { duration: '1m', target: 0 },
+  ],
+};
+```
+
+### Smoke Testing (Minimal Validation)
+Light load to verify script and basic functionality.
+
+```javascript
+export const options = {
+  vus: 5,
+  duration: '1m',
+};
+```
+
+### Breakpoint Testing
+Find maximum capacity by incrementally increasing load.
+
+```javascript
+export const options = {
+  stages: [
+    { duration: '2m', target: 50 },
+    { duration: '2m', target: 100 },
+    { duration: '2m', target: 150 },
+    { duration: '2m', target: 200 },
+    { duration: '2m', target: 250 },
+    { duration: '2m', target: 0 },
+  ],
+};
+```
+
+---
+
+## Scenario Executors
+
+| Executor | Use Case | Key Params |
+| -------- | -------- | ---------- |
+| **shared-iterations** | Fixed total iterations across all VUs | `iterations`, `vus` |
+| **per-vu-iterations** | Each VU runs N iterations | `vus`, `iterations` |
+| **constant-vus** | Fixed VU count for duration | `vus`, `duration` |
+| **ramping-vus** | Ramp VUs up/down | `startVUs`, `stages`, `gracefulRampDown` |
+| **constant-arrival-rate** | Fixed request rate (arrivals/sec) | `rate`, `timeUnit`, `duration`, `preAllocatedVUs`, `maxVUs` |
+| **ramping-arrival-rate** | Variable request rate | `startRate`, `stages`, `preAllocatedVUs`, `maxVUs` |
+| **externally-controlled** | Control VUs from external source | `maxVUs`, `duration` |
+
+### Example: Multiple Scenarios
+
+```javascript
+export const options = {
+  scenarios: {
+    browse: {
+      executor: 'constant-vus',
+      vus: 10,
+      duration: '5m',
+      exec: 'browseFlow',
+      startTime: '0s',
+    },
+    api: {
+      executor: 'constant-arrival-rate',
+      rate: 20,
+      timeUnit: '1s',
+      duration: '5m',
+      preAllocatedVUs: 10,
+      maxVUs: 50,
+      exec: 'apiFlow',
+      startTime: '0s',
+    },
+  },
+};
+```
+
+---
+
+## Thresholds
+
+### Common Threshold Patterns
+
+```javascript
+export const options = {
+  thresholds: {
+    // p95 response time under 200ms
+    http_req_duration: ['p(95)<200'],
+    // Error rate under 1%
+    http_req_failed: ['rate<0.01'],
+    // Combined: both must pass
+    'http_req_duration{name:api}': ['p(99)<500'],
+    'http_req_failed{name:api}': ['rate<0.005'],
+  },
+};
+```
+
+### Threshold Operators
+
+| Operator | Meaning |
+| -------- | ------- |
+| `<` | Less than |
+| `<=` | Less than or equal |
+| `>` | Greater than |
+| `>=` | Greater than or equal |
+| `==` | Equal |
+
+### Built-in Metrics
+
+| Metric | Description |
+| ------ | ----------- |
+| `http_req_duration` | Request duration (ms) |
+| `http_req_failed` | Failed request rate (0–1) |
+| `http_reqs` | Total HTTP requests |
+| `iterations` | Completed iterations |
+| `vus` | Current virtual users |
+| `vus_max` | Max configured VUs |
+
+---
+
+## Custom Metrics
+
+### Trend (Duration)
+```javascript
+import { Trend } from 'k6/metrics';
+const myTrend = new Trend('my_custom_duration');
+
+export default function () {
+  const start = Date.now();
+  // ... do work ...
+  myTrend.add(Date.now() - start);
+}
+```
+
+### Rate (Success/Failure)
+```javascript
+import { Rate } from 'k6/metrics';
+const myRate = new Rate('my_success_rate');
+
+export default function () {
+  const success = doSomething();
+  myRate.add(success);
+}
+```
+
+### Counter
+```javascript
+import { Counter } from 'k6/metrics';
+const myCounter = new Counter('my_counter');
+
+export default function () {
+  myCounter.add(1);
+}
+```
+
+### Gauge (Latest Value)
+```javascript
+import { Gauge } from 'k6/metrics';
+const myGauge = new Gauge('my_gauge');
+
+export default function () {
+  myGauge.add(someValue);
+}
+```
+
+---
+
+## Groups
+
+Organize related operations for clearer output and metrics.
+
+```javascript
+import http from 'k6/http';
+import { group } from 'k6';
+
+export default function () {
+  group('Homepage', function () {
+    const res = http.get('https://example.com/');
+    // assertions
+  });
+
+  group('API - List', function () {
+    const res = http.get('https://api.example.com/items');
+    // assertions
+  });
+
+  group('API - Create', function () {
+    const res = http.post('https://api.example.com/items', JSON.stringify({ name: 'item' }), {
+      headers: { 'Content-Type': 'application/json' },
+    });
+    // assertions
+  });
+}
+```
+
+---
+
+## Checks vs Thresholds
+
+**Checks** — Assertions per iteration; don't fail the test.
+```javascript
+import { check } from 'k6';
+import http from 'k6/http';
+
+export default function () {
+  const res = http.get('https://example.com/');
+  check(res, { 'status is 200': (r) => r.status === 200 });
+}
+```
+
+**Thresholds** — Pass/fail criteria for the entire test run.
+```javascript
+export const options = {
+  thresholds: {
+    checks: ['rate>0.95'],
+  },
+};
+```
+
+---
+
+## HTTP Patterns
+
+### Basic GET/POST
+```javascript
+import http from 'k6/http';
+
+const res = http.get('https://api.example.com/items');
+const res2 = http.post('https://api.example.com/items', JSON.stringify({ name: 'test' }), {
+  headers: { 'Content-Type': 'application/json' },
+});
+```
+
+### Correlation (Extract from Response)
+```javascript
+const res = http.get('https://api.example.com/login');
+const token = res.json('token');
+http.get('https://api.example.com/protected', {
+  headers: { Authorization: `Bearer ${token}` },
+});
+```
+
+### Parameterization (CSV)
+```javascript
+import { SharedArray } from 'k6/data';
+const data = new SharedArray('users', function () {
+  return JSON.parse(open('./users.json'));
+});
+
+export default function () {
+  const user = data[__ITER % data.length];
+  http.post('https://api.example.com/login', JSON.stringify(user));
+}
+```

package/skills/qa-linear-integration/SKILL.md

@@ -0,0 +1,137 @@
+---
+name: qa-linear-integration
+description: Linear integration for creating issues, managing projects/cycles, and tracking QA workflows via GraphQL API or Linear MCP.
+dependencies:
+  recommended:
+    - qa-bug-ticket-creator
+    - qa-task-creator
+---
+
+# QA Linear Integration
+
+## Purpose
+
+Integrate QA workflow with Linear for issue tracking and project management. Create and update issues, manage projects and cycles, and sync with qa-bug-ticket-creator and qa-task-creator for end-to-end QA traceability.
+
+## Features
+
+| Feature | Description |
+| ------- | ----------- |
+| **Create/update issues** | Bug, Story, Task via GraphQL mutations |
+| **Projects and cycles** | Assign issues to projects; add to cycles (sprints) |
+| **Labels and priority** | Map severity/priority to Linear labels and priority |
+| **Issue relations** | Blocks, relates to, duplicates |
+| **Team assignment** | Assign issues to teams |
+| **GraphQL API** | Full GraphQL for queries and mutations |
+
+## Authentication
+
+Store in `.env` (never hardcode):
+
+```
+LINEAR_API_KEY=lin_api_xxxxxxxxxxxx
+```
+
+- **Header:** `Authorization: Bearer {LINEAR_API_KEY}`
+- Linear uses API keys; no Basic Auth. Create keys at Linear → Settings → API.
+
+## Key API Patterns
+
+| Operation | GraphQL |
+| --------- | ------- |
+| Create issue | `mutation { issueCreate(input: {...}) { issue { id identifier url } } }` |
+| Update issue | `mutation { issueUpdate(id: "...", input: {...}) { issue { ... } } }` |
+| Query issues | `query { issues(filter: {...}) { nodes { id identifier title state { name } } } }` |
+| Projects | `query { projects { nodes { id name } } }` |
+| Teams | `query { teams { nodes { id name key } } }` |
+| Cycles | `query { cycles(filter: { teamId: { eq: "..." } }) { nodes { id name } } }` |
+
+See `references/api-patterns.md` for full GraphQL examples.
+
+## Integration with QA Skills
+
+### qa-bug-ticket-creator
+
+When creating a bug report for Linear:
+
+1. **Input** — Bug report from test failure (title, expected/actual, steps, severity, component)
+2. **Map** — Use `references/field-mapping.md` to map to Linear fields
+3. **Create** — `issueCreate` with `teamId`, `title`, `description`, `priority`, `labels`
+4. **Link** — Add "blocks" or "relates to" for related issues when applicable
+
+### qa-task-creator
+
+When creating tasks for Linear:
+
+1. **Input** — Task from coverage gap, spec finding, or bug fix request
+2. **Map** — Map task type to Linear issue type (Story, Task)
+3. **Create** — `issueCreate` with project, cycle, labels
+4. **Link** — Use `parentId` for sub-tasks; "blocks" for fix tasks referencing bugs
+
+## Trigger Phrases
+
+- "Create Linear issue for [bug/task description]"
+- "Add bug to Linear from test failure"
+- "Create Linear story for [feature]"
+- "Sync QA tasks to Linear"
+- "Linear issue from qa-bug-ticket-creator output"
+- "Add to Linear cycle [name]"
+- "Query Linear issues by [filter]"
+
+## Workflow
+
+1. **Auth** — Load `LINEAR_API_KEY` from `.env`
+2. **Resolve IDs** — Query teams, projects, cycles to get IDs (or use user-provided)
+3. **Map fields** — Apply `references/field-mapping.md` for QA → Linear
+4. **Execute** — Run GraphQL mutation (issueCreate, issueUpdate)
+5. **Output** — Return issue identifier (e.g., `BUG-123`), URL, and summary
+
+## Scope
+
+**Can do (autonomous):**
+- Create and update Linear issues via GraphQL
+- Map QA bug/task fields to Linear fields
+- Query issues, projects, teams, cycles
+- Add labels, priority, project, cycle
+- Create issue relations (blocks, relates to)
+- Work with qa-bug-ticket-creator and qa-task-creator outputs
+
+**Cannot do (requires confirmation):**
+- Create issues in workspaces without API access
+- Assign to specific users without mapping
+- Delete or archive issues
+- Modify workspace settings
+
+**Will not do (out of scope):**
+- Modify production or test code
+- Execute tests or deployments
+- Manage Linear workspace billing or admin
+
+## Quality Checklist
+
+- [ ] `LINEAR_API_KEY` loaded from `.env`; never hardcoded
+- [ ] Field mapping applied per `references/field-mapping.md`
+- [ ] Issue includes title, description, and appropriate labels/priority
+- [ ] Team ID (or project) specified for issue creation
+- [ ] GraphQL errors handled; user-friendly message on failure
+- [ ] Issue identifier and URL returned to user
+- [ ] Relations (blocks, relates to) set when linking to bugs/tasks
+
+## Troubleshooting
+
+| Symptom | Likely Cause | Fix |
+| ------- | ------------ | --- |
+| 401 Unauthorized | Invalid or missing API key | Verify `LINEAR_API_KEY` in `.env`; regenerate if needed |
+| Team not found | Wrong team ID or key | Query `teams { nodes { id key } }`; use correct ID |
+| Invalid input | Required field missing | Check `references/field-mapping.md`; ensure `teamId` and `title` present |
+| Cycle not found | Cycle doesn't exist or wrong team | Query cycles for team; use active cycle ID |
+| GraphQL errors | Malformed mutation/query | Validate query syntax; check Linear API docs |
+| Label not applied | Label doesn't exist in workspace | Create label in Linear or use existing label name |
+| Relation fails | Invalid issue ID | Verify target issue exists; use correct `id` (UUID) |
+
+## Reference Files
+
+| Topic | File |
+| ----- | ---- |
+| GraphQL API patterns | `references/api-patterns.md` |
+| QA → Linear field mapping | `references/field-mapping.md` |

package/skills/qa-linear-integration/references/api-patterns.md

@@ -0,0 +1,249 @@
+# Linear GraphQL API Patterns
+
+*GraphQL operations for creating, querying, and updating Linear issues.*
+
+---
+
+## Base URL
+
+```
+https://api.linear.app/graphql
+```
+
+**Headers:**
+```
+Authorization: Bearer {LINEAR_API_KEY}
+Content-Type: application/json
+```
+
+---
+
+## Create Issue
+
+```graphql
+mutation IssueCreate($input: IssueCreateInput!) {
+  issueCreate(input: $input) {
+    issue {
+      id
+      identifier
+      title
+      url
+      state { name }
+    }
+    success
+  }
+}
+```
+
+**Variables:**
+```json
+{
+  "input": {
+    "teamId": "uuid-of-team",
+    "title": "Login fails when password contains special chars",
+    "description": "**Expected:** User should log in successfully.\n\n**Actual:** 500 error.\n\n**Steps:** 1. Go to /login 2. Enter password with !@# 3. Submit",
+    "priority": 1,
+    "labelIds": ["uuid-of-label"],
+    "projectId": "uuid-of-project",
+    "cycleId": "uuid-of-cycle"
+  }
+}
+```
+
+**Priority values:** 0 = No priority, 1 = Urgent, 2 = High, 3 = Medium, 4 = Low.
+
+---
+
+## Update Issue
+
+```graphql
+mutation IssueUpdate($id: String!, $input: IssueUpdateInput!) {
+  issueUpdate(id: $id, input: $input) {
+    issue {
+      id
+      identifier
+      title
+      state { name }
+    }
+    success
+  }
+}
+```
+
+**Variables:**
+```json
+{
+  "id": "uuid-of-issue",
+  "input": {
+    "title": "Updated title",
+    "description": "Updated description",
+    "priority": 2,
+    "stateId": "uuid-of-state"
+  }
+}
+```
+
+---
+
+## Query Issues
+
+```graphql
+query Issues($filter: IssueFilter) {
+  issues(filter: $filter, first: 50) {
+    nodes {
+      id
+      identifier
+      title
+      description
+      state { name }
+      priority
+      url
+      createdAt
+    }
+    pageInfo { hasNextPage endCursor }
+  }
+}
+```
+
+**Filter examples:**
+```json
+{
+  "filter": {
+    "state": { "name": { "neq": "Done" } },
+    "team": { "key": { "eq": "ENG" } }
+  }
+}
+```
+
+```json
+{
+  "filter": {
+    "identifier": { "containsIgnoreCase": "BUG" }
+  }
+}
+```
+
+---
+
+## Query Teams
+
+```graphql
+query Teams {
+  teams {
+    nodes {
+      id
+      name
+      key
+    }
+  }
+}
+```
+
+Use `id` for `teamId` in issueCreate.
+
+---
+
+## Query Projects
+
+```graphql
+query Projects {
+  projects {
+    nodes {
+      id
+      name
+      state
+    }
+  }
+}
+```
+
+---
+
+## Query Cycles
+
+```graphql
+query Cycles($filter: CycleFilter) {
+  cycles(filter: $filter, first: 20) {
+    nodes {
+      id
+      name
+      state
+      startsAt
+      endsAt
+    }
+  }
+}
+```
+
+**Filter by team:**
+```json
+{
+  "filter": {
+    "teamId": { "eq": "uuid-of-team" }
+  }
+}
+```
+
+---
+
+## Create Issue Relation (Blocks / Relates To)
+
+```graphql
+mutation IssueRelationCreate($input: IssueRelationCreateInput!) {
+  issueRelationCreate(input: $input) {
+    issueRelation {
+      id
+    }
+    success
+  }
+}
+```
+
+**Variables (blocks):**
+```json
+{
+  "input": {
+    "issueId": "uuid-of-blocking-issue",
+    "relatedIssueId": "uuid-of-blocked-issue",
+    "type": "blocks"
+  }
+}
+```
+
+**Relation types:** `blocks`, `duplicate`, `related`.
+
+---
+
+## Create Sub-Issue (Parent)
+
+Use `parentId` in issueCreate:
+
+```json
+{
+  "input": {
+    "teamId": "uuid",
+    "title": "Sub-task title",
+    "parentId": "uuid-of-parent-issue"
+  }
+}
+```
+
+---
+
+## Error Handling
+
+GraphQL returns `errors` array on failure:
+
+```json
+{
+  "data": null,
+  "errors": [
+    {
+      "message": "Issue validation failed",
+      "extensions": { "code": "VALIDATION_ERROR" }
+    }
+  ]
+}
+```
+
+Check `errors` before using `data`; surface `message` to user.