opencode-skills-collection 3.1.11 → 3.1.13

package/bundled-skills/postman-newman-automation/SKILL.md

@@ -0,0 +1,311 @@
+---
+name: postman-newman-automation
+description: Generate Newman CLI commands, configuration files, Jenkins pipeline scripts, and shell automation for running Postman collections in CI/CD or local environments. Use this skill whenever the user wants to run Postman collections from the command line, automate API tests, integrate...
+risk: unknown
+source: https://github.com/LambdaTest/agent-skills/tree/main/api-skill/postman/postman-to-newman
+source_repo: LambdaTest/agent-skills
+source_type: community
+date_added: 2026-07-01
+license: MIT
+license_source: https://github.com/LambdaTest/agent-skills/blob/main/LICENSE
+---
+
+# Postman Newman Automation
+## When to Use
+
+Use this skill when you need generate Newman CLI commands, configuration files, Jenkins pipeline scripts, and shell automation for running Postman collections in CI/CD or local environments. Use this skill whenever the user wants to run Postman collections from the command line, automate API tests, integrate...
+
+
+Generates **Newman CLI** commands, **shell scripts**, and **Jenkins pipeline** configs
+for running Postman collections in automated environments.
+
+---
+
+## Newman Basics
+
+Newman is Postman's CLI runner. Install with:
+```bash
+npm install -g newman
+# Optional HTML reporter:
+npm install -g newman-reporter-htmlextra
+```
+
+### Core Command Structure
+```bash
+newman run <collection> \
+  --environment <env-file> \
+  --globals <globals-file> \
+  --iteration-count <n> \
+  --iteration-data <csv-or-json> \
+  --reporters <reporter-list> \
+  --reporter-htmlextra-export <output.html> \
+  --reporter-junit-export <results.xml> \
+  --timeout-request <ms> \
+  --delay-request <ms> \
+  --bail \
+  --color on
+```
+
+---
+
+## Step 1 — Gather Requirements
+
+Ask or infer from context:
+
+| Parameter | Question |
+|---|---|
+| Collection source | File path, URL, or Postman API UID? |
+| Environment | File path or inline variables? |
+| Reporter(s) | CLI only, HTML report, JUnit XML? |
+| Fail behavior | Stop on first failure (`--bail`) or run all? |
+| Iterations | Single run or data-driven (CSV/JSON)? |
+| Target | Local shell, Jenkins, or both? |
+
+---
+
+## Step 2 — Generate Newman Command
+
+### Basic run (local)
+```bash
+newman run collection.json \
+  --environment environment.json \
+  --reporters cli,htmlextra \
+  --reporter-htmlextra-export reports/report.html \
+  --bail
+```
+
+### Run from Postman API (by UID)
+```bash
+newman run "https://api.getpostman.com/collections/<UID>?apikey={{POSTMAN_API_KEY}}" \
+  --environment environment.json \
+  --reporters cli,junit \
+  --reporter-junit-export results/junit.xml
+```
+
+### Data-driven run (CSV)
+```bash
+newman run collection.json \
+  --iteration-data test-data.csv \
+  --iteration-count 5 \
+  --reporters cli,htmlextra \
+  --reporter-htmlextra-export reports/data-driven-report.html
+```
+
+### With environment variable overrides (no file needed)
+```bash
+newman run collection.json \
+  --env-var "base_url=https://staging.api.example.com" \
+  --env-var "token=abc123" \
+  --reporters cli
+```
+
+---
+
+## Step 3 — Shell Script
+
+Generate a reusable shell script:
+
+```bash
+#!/bin/bash
+set -e
+
+# Configuration
+COLLECTION="./collection.json"
+ENVIRONMENT="./environment.json"
+REPORT_DIR="./reports"
+TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
+
+# Ensure report directory exists
+mkdir -p "$REPORT_DIR"
+
+echo "Running Newman collection: $COLLECTION"
+
+newman run "$COLLECTION" \
+  --environment "$ENVIRONMENT" \
+  --reporters cli,htmlextra,junit \
+  --reporter-htmlextra-export "$REPORT_DIR/report_$TIMESTAMP.html" \
+  --reporter-junit-export "$REPORT_DIR/junit_$TIMESTAMP.xml" \
+  --timeout-request 10000 \
+  --bail
+
+EXIT_CODE=$?
+
+if [ $EXIT_CODE -eq 0 ]; then
+  echo "✅ All tests passed."
+else
+  echo "❌ Tests failed. Check report: $REPORT_DIR/report_$TIMESTAMP.html"
+  exit $EXIT_CODE
+fi
+```
+
+---
+
+## Step 4 — Jenkins Pipeline
+
+### Declarative Jenkinsfile (preferred)
+
+```groovy
+pipeline {
+  agent any
+
+  environment {
+    POSTMAN_ENV = credentials('postman-environment-file') // Jenkins credential ID
+  }
+
+  stages {
+    stage('Install Newman') {
+      steps {
+        sh 'npm install -g newman newman-reporter-htmlextra'
+      }
+    }
+
+    stage('Run API Tests') {
+      steps {
+        sh """
+          newman run collection.json \\
+            --environment ${POSTMAN_ENV} \\
+            --reporters cli,htmlextra,junit \\
+            --reporter-htmlextra-export reports/report.html \\
+            --reporter-junit-export reports/junit.xml \\
+            --timeout-request 10000 \\
+            --bail
+        """
+      }
+    }
+  }
+
+  post {
+    always {
+      // Archive HTML report
+      publishHTML(target: [
+        allowMissing: false,
+        alwaysLinkToLastBuild: true,
+        keepAll: true,
+        reportDir: 'reports',
+        reportFiles: 'report.html',
+        reportName: 'Newman API Test Report'
+      ])
+      // Archive JUnit results
+      junit 'reports/junit.xml'
+    }
+    failure {
+      echo 'API tests failed! Check the Newman report.'
+    }
+  }
+}
+```
+
+### Scripted Jenkinsfile (if declarative not available)
+
+```groovy
+node {
+  stage('Install Newman') {
+    sh 'npm install -g newman newman-reporter-htmlextra'
+  }
+
+  stage('Run API Tests') {
+    try {
+      sh """
+        newman run collection.json \\
+          --environment environment.json \\
+          --reporters cli,junit \\
+          --reporter-junit-export reports/junit.xml \\
+          --bail
+      """
+    } catch (err) {
+      currentBuild.result = 'FAILURE'
+      throw err
+    } finally {
+      junit 'reports/junit.xml'
+    }
+  }
+}
+```
+
+### Jenkins with environment variables (no credentials file)
+```groovy
+environment {
+  BASE_URL = 'https://api.example.com'
+  API_TOKEN = credentials('api-token-secret')
+}
+
+steps {
+  sh """
+    newman run collection.json \\
+      --env-var "base_url=${BASE_URL}" \\
+      --env-var "token=${API_TOKEN}" \\
+      --reporters cli,junit \\
+      --reporter-junit-export results/junit.xml
+  """
+}
+```
+
+---
+
+## Step 5 — Reporter Reference
+
+| Reporter | Install | Flag | Output |
+|---|---|---|---|
+| `cli` | built-in | `--reporters cli` | Terminal output |
+| `junit` | built-in | `--reporters junit` | JUnit XML (for Jenkins) |
+| `htmlextra` | `npm i -g newman-reporter-htmlextra` | `--reporters htmlextra` | Rich HTML report |
+| `json` | built-in | `--reporters json` | Raw JSON results |
+
+Multiple reporters: `--reporters cli,htmlextra,junit`
+
+---
+
+## Step 6 — Output
+
+Provide based on what the user needs:
+
+1. **Newman command** — ready to paste in terminal
+2. **Shell script** (`run-tests.sh`) — with exit code handling
+3. **Jenkinsfile** — declarative or scripted based on context
+4. **Setup notes** — Node.js version requirement (≥14), npm install commands
+5. **Report locations** — where output files will be written
+
+---
+
+## Common Flags Quick Reference
+
+| Flag | Purpose |
+|---|---|
+| `--bail` | Stop run on first test failure |
+| `--timeout-request 5000` | Per-request timeout in ms |
+| `--delay-request 200` | Delay between requests in ms |
+| `--iteration-count 3` | Run collection N times |
+| `--folder "Folder Name"` | Run only a specific folder |
+| `--env-var "k=v"` | Inline environment variable |
+| `--suppress-exit-code` | Always exit 0 (don't fail CI) |
+| `--verbose` | Show full request/response details |
+| `--color off` | Disable color (useful for logs) |
+
+---
+
+## After Completing the Newman Commands
+
+Once the CLI command output is delivered, ask the user:
+
+"Would you like me to generate API documentation for this design? (yes/no)"
+
+If the user says **yes**:
+- Check if the API Documentation skill is available in the installed skills list
+- If the skill **is available**:
+  - Read and follow the instructions in the API Documentation skill
+  - Use the API design output above as the input
+  - Deliver the documentation as plain text output
+- If the skill **is NOT available**:
+  - Inform the user: "It looks like the API Documentation skill isn't installed.
+    You can install it and re-run.
+
+If the user says **no**:
+- End the task here
+
+---
+
+## Limitations
+
+- Use this skill only when the task clearly matches its upstream source and local project context.
+- Verify commands, generated code, dependencies, credentials, and external service behavior before applying changes.
+- Do not treat examples as a substitute for environment-specific tests, security review, or user approval for destructive or costly actions.

package/bundled-skills/postman-openapi-converter/SKILL.md

@@ -0,0 +1,174 @@
+---
+name: postman-openapi-converter
+description: Convert OpenAPI 3.x or Swagger 2.0 specs (YAML or JSON) into complete, import-ready Postman Collection v2.1 JSON files. Use this skill whenever the user provides or references an OpenAPI spec, Swagger file, openapi.yaml, swagger.json, or uses phrases like "convert my OpenAPI spec",...
+risk: unknown
+source: https://github.com/LambdaTest/agent-skills/tree/main/api-skill/postman/postman-openapi-converter
+source_repo: LambdaTest/agent-skills
+source_type: community
+date_added: 2026-07-01
+license: MIT
+license_source: https://github.com/LambdaTest/agent-skills/blob/main/LICENSE
+---
+
+# OpenAPI → Postman Collection Converter
+## When to Use
+
+Use this skill when you need convert OpenAPI 3.x or Swagger 2.0 specs (YAML or JSON) into complete, import-ready Postman Collection v2.1 JSON files. Use this skill whenever the user provides or references an OpenAPI spec, Swagger file, openapi.yaml, swagger.json, or uses phrases like "convert my OpenAPI spec",...
+
+
+Converts **OpenAPI 3.x** or **Swagger 2.0** specs into a valid **Postman Collection v2.1**.
+
+---
+
+## Step 1 — Detect & Validate Input
+
+Identify the spec version from the input:
+- `openapi: 3.x.x` → OpenAPI 3
+- `swagger: "2.0"` → Swagger 2
+
+If the input is truncated or partial, convert what's available and note missing sections.
+
+---
+
+## Step 2 — Extraction Mapping
+
+### OpenAPI 3 → Postman
+
+| OpenAPI field | Postman mapping |
+|---|---|
+| `info.title` | Collection name |
+| `info.description` | Collection description |
+| `servers[0].url` | `{{base_url}}` variable |
+| `paths.<path>.<method>` | One request item per operation |
+| `operationId` or `summary` | Request name |
+| `parameters` (path/query/header) | URL path variables, query params, headers |
+| `requestBody.content.application/json.schema` | Body (raw JSON), generate example from schema |
+| `responses` | Saved example responses |
+| `components.securitySchemes` | Collection-level auth |
+| `tags` | Folder grouping |
+
+### Swagger 2 → Postman
+
+| Swagger field | Postman mapping |
+|---|---|
+| `host` + `basePath` | `{{base_url}}` |
+| `paths.<path>.<method>` | Request item |
+| `parameters` | Query/path/header/body params |
+| `consumes` / `produces` | Content-Type / Accept headers |
+| `securityDefinitions` | Collection auth |
+| `tags` | Folders |
+
+---
+
+## Step 3 — Generate Example Bodies
+
+For each request with a `requestBody` or `body` parameter, generate a realistic example JSON body from the schema:
+- Use property names as keys
+- Infer sensible example values from type + format (e.g., `"email"` format → `"user@example.com"`, `"date-time"` → `"2024-01-15T10:30:00Z"`)
+- For `$ref` schemas, resolve them inline
+
+---
+
+## Step 4 — Auth Handling
+
+Map security schemes to Postman auth:
+
+| OpenAPI scheme | Postman auth type |
+|---|---|
+| `http: bearer` | `bearer` with `{{token}}` |
+| `http: basic` | `basic` with `{{username}}` / `{{password}}` |
+| `apiKey: header` | `apikey` header with `{{api_key}}` |
+| `apiKey: query` | `apikey` query param |
+| `oauth2` | `oauth2` (note: requires manual token setup) |
+
+Apply auth at **collection level** if all endpoints share the same scheme. Override at request level for exceptions.
+
+---
+
+## Step 5 — Build Collection JSON
+
+Use the standard v2.1 structure (same schema as postman-collection-generator skill).
+
+Key differences for spec-converted collections:
+- Always group by `tags` into folders
+- Include `description` field on each request from `operationId` + `summary` + `description`
+- Add saved example responses where `responses` are defined in the spec
+
+```json
+"response": [
+  {
+    "name": "200 OK",
+    "status": "OK",
+    "code": 200,
+    "header": [{ "key": "Content-Type", "value": "application/json" }],
+    "body": "{ \"id\": 1, \"name\": \"example\" }",
+    "originalRequest": { <copy of the request> }
+  }
+]
+```
+
+---
+
+## Step 6 — Environment File
+
+Extract all variables into a companion environment:
+- `base_url` from `servers[0].url` or `host + basePath`
+- `token`, `api_key`, `username`, `password` as empty placeholders
+- Any server variables from `servers[0].variables`
+
+---
+
+## Step 7 — Output
+
+1. `collection.json` — Full Postman Collection v2.1
+2. `environment.json` — Matching environment file
+3. **Conversion summary**: number of endpoints converted, folders created, auth type detected, any fields skipped or approximated
+4. Import instructions
+
+---
+
+## Edge Cases
+
+- **`$ref` chains**: Resolve all `$ref` pointers inline before mapping
+- **`allOf` / `oneOf` / `anyOf`**: Use the first/primary schema for body generation; note alternatives in description
+- **Path parameters**: Convert `{param}` to `:param` in URL path AND add to `variable` array in url object
+- **Multiple content types**: Prefer `application/json`; note others in request description
+- **No operationId**: Generate name from `METHOD /path` (e.g., `GET /users/{id}` → `Get User by ID`)
+
+---
+
+## Quality Checklist
+
+- [ ] Every `paths` entry produces at least one request
+- [ ] Path params use `:param` format in Postman URL
+- [ ] All `$ref` resolved — no raw `$ref` strings in output
+- [ ] Auth tokens are `{{variables}}`, never hardcoded
+- [ ] JSON output is valid and importable
+
+---
+
+## After Completing the API Design
+
+Once the API design output is delivered, ask the user:
+
+"Would you like me to generate API documentation for this design? (yes/no)"
+
+If the user says **yes**:
+- Check if the API Documentation skill is available in the installed skills list
+- If the skill **is available**:
+  - Read and follow the instructions in the API Documentation skill
+  - Use the API design output above as the input
+- If the skill **is NOT available**:
+  - Inform the user: "It looks like the API Documentation skill isn't installed.
+    You can install it and re-run.
+
+If the user says **no**:
+- End the task here
+
+---
+
+## Limitations
+
+- Use this skill only when the task clearly matches its upstream source and local project context.
+- Verify commands, generated code, dependencies, credentials, and external service behavior before applying changes.
+- Do not treat examples as a substitute for environment-specific tests, security review, or user approval for destructive or costly actions.

package/bundled-skills/power-user-cultivation/README.md

@@ -0,0 +1,78 @@
+# power-user-cultivation
+
+**Turn users into advocates and contributors** — identifying, nurturing, and empowering your developer champions.
+
+## What It Does
+
+Helps you identify your most engaged developers and create programs that turn them into advocates, content creators, and contributors. No forced evangelism — genuine value exchange for developers who love your product.
+
+## When to Use
+
+- Identifying potential advocates in your user base
+- Building a champion or ambassador program
+- Creating contributor experience for open source
+- Launching a referral program
+- Starting user-generated content initiatives
+- When you say "power users," "developer advocates," "champion program," or "UGC"
+
+## Quick Start
+
+```
+/power-user-cultivation
+
+Help me identify potential advocates from our user base and design
+a champion program. We have about 5,000 active developers using our API.
+```
+
+## The Power User Spectrum
+
+| Level | Behavior | Your Response |
+|-------|----------|---------------|
+| Active User | Uses product regularly | Keep shipping |
+| Engaged User | Participates in community | Respond quickly |
+| Advocate | Recommends unprompted | Early access, direct line |
+| Champion | Creates content, helps others | Formal program |
+| Contributor | Contributes code/docs | Contributor program |
+
+## Key Principles
+
+1. **Don't push everyone up the spectrum — meet them where they are**
+2. **No content quotas — advocates create because they want to**
+3. **Credits > cash for referrals (less MLM feeling)**
+4. **Recognition must be specific, public, and timely**
+5. **Start small (5-10 champions) and grow**
+
+## Files
+
+| File | Description |
+|------|-------------|
+| `SKILL.md` | Full skill instructions |
+
+## Program Templates Included
+
+- Champion program structure
+- CONTRIBUTING.md for open source
+- Content bounty program
+- Referral program design
+- Recognition workflow
+
+## Identifying Advocates
+
+Look for signals:
+- Top 10% by usage
+- Answers community questions
+- Created content about you
+- Files thoughtful bug reports
+- Positive social mentions
+
+## Tools
+
+- **[Octolens](https://octolens.com)** — Discover advocates through positive mentions, track content, identify power users
+- **FirstPromoter** — Referral management
+
+## Related Skills
+
+- `developer-audience-context` — What motivates your developers
+- `developer-churn` — Keep power users from leaving
+- `developer-listening` — Find candidates through monitoring
+- `hackathon-sponsorship` — Events where advocates shine