@intentsolutionsio/performance-test-suite 1.0.0

package/.claude-plugin/plugin.json

@@ -0,0 +1,19 @@
+{
+  "name": "performance-test-suite",
+  "version": "1.0.0",
+  "description": "Load testing and performance benchmarking with metrics analysis and bottleneck identification",
+  "author": {
+    "name": "Claude Code Plugins",
+    "email": "[email protected]"
+  },
+  "repository": "https://github.com/jeremylongshore/claude-code-plugins",
+  "license": "MIT",
+  "keywords": [
+    "testing",
+    "performance",
+    "load-testing",
+    "benchmarking",
+    "stress-testing",
+    "agent-skills"
+  ]
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Claude Code Plugins
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,282 @@
+# Performance Test Suite Plugin
+
+Comprehensive load testing and performance benchmarking with intelligent metrics analysis, bottleneck identification, and actionable recommendations.
+
+## Features
+
+- **Load testing** - Gradual ramp-up, sustained load, peak capacity
+- **Stress testing** - Breaking point identification, recovery validation
+- **Spike testing** - Sudden traffic surges, flash sale scenarios
+- **Endurance testing** - Long-running stability, memory leak detection
+- **Metrics analysis** - Response times, throughput, error rates, resources
+- **Bottleneck identification** - CPU, memory, database, network issues
+- **Comprehensive reporting** - Percentiles, graphs, recommendations
+
+## Installation
+
+```bash
+/plugin install performance-test-suite@claude-code-plugins-plus
+```
+
+## Usage
+
+The performance testing agent activates automatically when discussing performance or load testing:
+
+### Design load test
+
+```
+Create a load test for the API that ramps up to 500 concurrent users over 5 minutes
+```
+
+### Stress test to find limits
+
+```
+Design a stress test to find the breaking point of the checkout API
+```
+
+### Spike test for flash sales
+
+```
+Create a spike test simulating a flash sale with sudden 10x traffic increase
+```
+
+### Endurance test for stability
+
+```
+Design an endurance test running at 200 users for 4 hours to check for memory leaks
+```
+
+## Test Types
+
+### 1. Load Testing
+
+Gradually increase load to test normal operating conditions:
+
+```javascript
+// k6 load test
+export let options = {
+  stages: [
+    { duration: '5m', target: 100 },   // Ramp up
+    { duration: '10m', target: 100 },  // Sustain
+    { duration: '5m', target: 0 },     // Ramp down
+  ],
+};
+```
+
+**Validates:**
+- Normal performance under expected load
+- Response times remain acceptable
+- Error rates stay low
+- Resources adequate for traffic
+
+### 2. Stress Testing
+
+Push system beyond normal load to find limits:
+
+```javascript
+// k6 stress test
+export let options = {
+  stages: [
+    { duration: '2m', target: 100 },
+    { duration: '5m', target: 200 },
+    { duration: '5m', target: 300 },
+    { duration: '5m', target: 400 },
+    { duration: '10m', target: 400 },
+  ],
+};
+```
+
+**Validates:**
+- Maximum capacity before failure
+- Graceful degradation under stress
+- Recovery after overload
+- Error handling at limits
+
+### 3. Spike Testing
+
+Sudden dramatic traffic increases:
+
+```javascript
+// k6 spike test
+export let options = {
+  stages: [
+    { duration: '10s', target: 50 },    // Normal load
+    { duration: '1m', target: 500 },    // Sudden spike
+    { duration: '3m', target: 500 },    // Sustain spike
+    { duration: '10s', target: 50 },    // Return to normal
+  ],
+};
+```
+
+**Validates:**
+- Auto-scaling response
+- Rate limiting effectiveness
+- System stability during surge
+- Recovery time after spike
+
+### 4. Endurance Testing (Soak Test)
+
+Extended duration at moderate load:
+
+```javascript
+// k6 endurance test
+export let options = {
+  stages: [
+    { duration: '2m', target: 200 },
+    { duration: '4h', target: 200 },    // Long soak
+    { duration: '2m', target: 0 },
+  ],
+};
+```
+
+**Validates:**
+- Memory leaks over time
+- Resource exhaustion
+- Connection pool issues
+- Long-term stability
+
+## Metrics Collected
+
+### Response Time Metrics
+
+- **Average** - Mean response time
+- **Median (P50)** - Half of requests faster
+- **P95** - 95% of requests faster (SLA metric)
+- **P99** - 99% of requests faster (tail latency)
+- **Max** - Slowest request
+
+### Throughput Metrics
+
+- **Requests/second** - Total throughput
+- **Success rate** - Percentage successful
+- **Error rate** - Percentage failed
+- **Data transferred** - Bandwidth usage
+
+### Resource Metrics
+
+- **CPU usage** - Average and peak utilization
+- **Memory usage** - Allocation and growth
+- **Network I/O** - Bandwidth consumption
+- **Disk I/O** - Read/write operations
+- **Database connections** - Pool usage
+
+## Bottleneck Identification
+
+The agent identifies common performance issues:
+
+### High CPU Usage
+- Inefficient algorithms
+- Missing caching
+- Excessive computations
+- Unoptimized loops
+
+### High Memory Usage
+- Memory leaks
+- Large object retention
+- Inefficient data structures
+- Missing garbage collection
+
+### Slow Database
+- N+1 query problems
+- Missing indexes
+- Inefficient queries
+- Connection pool exhaustion
+
+### Network Saturation
+- Large response payloads
+- Missing compression
+- Too many requests
+- Inefficient protocols
+
+## Example Report
+
+```
+Performance Test Report
+=======================
+Test: Load Test - API Endpoints
+Date: 2025-10-11 14:30:00
+Duration: 20 minutes
+Max Virtual Users: 300
+
+ Response Time Metrics
+  Average: 145ms
+  Median (P50): 120ms
+  P95: 280ms  (Target: <300ms)
+  P99: 450ms  (Target: <500ms)
+  Max: 1,230ms
+
+ Throughput
+  Total Requests: 90,000
+  Requests/sec: 75
+  Success Rate: 99.4% 
+  Error Rate: 0.6%
+
+ Resource Utilization
+  CPU: 68% avg, 87% peak
+  Memory: 2.8 GB / 4 GB (70%)
+  Network: 22 MB/s avg
+
+ Bottlenecks Identified
+  1. GET /api/users - P95: 850ms (database index needed)
+  2. Database connection pool at 95% usage
+  3. Memory climbing 50MB/hour (potential leak)
+
+ Recommendations
+  1. Add index on users.email column → -70% query time
+  2. Increase connection pool: 20 → 50 connections
+  3. Implement Redis caching for user list endpoint
+  4. Investigate session manager memory leak
+  5. Consider horizontal scaling at 350+ users
+
+ Pass Criteria Met: 4/5
+   P95 response time < 300ms
+   P99 response time < 500ms
+   Error rate < 1%
+   Success rate > 99%
+   No memory leaks detected
+```
+
+## Supported Tools
+
+The agent generates tests for popular tools:
+
+| Tool | Language | Best For |
+|------|----------|----------|
+| k6 | JavaScript | Modern API testing, great DX |
+| Apache JMeter | Java | Enterprise, GUI-based |
+| Gatling | Scala | High load, excellent reports |
+| Locust | Python | Distributed testing, custom logic |
+| Artillery | Node.js | Quick setup, YAML config |
+| wrk | C | Raw HTTP benchmarking |
+
+## Best Practices Applied
+
+- **Realistic scenarios** - Simulate actual user behavior
+- **Gradual ramp-up** - Don't spike from 0 to max instantly
+- **Think time** - Pause between requests like real users
+- **Data variation** - Use different data each request
+- **Monitor everything** - Track all system resources
+- **Production-like environment** - Match production as closely as possible
+- **Baseline comparison** - Compare against previous tests
+- **Clear success criteria** - Define thresholds before testing
+
+## Requirements
+
+- Claude Code CLI
+- Performance testing tool (k6, Locust, JMeter, etc.)
+- Monitoring tools (optional but recommended)
+- Test environment matching production
+
+## Tips
+
+1. **Start small** - Begin with 10 users, scale up gradually
+2. **Test one thing** - Isolate variables (don't change code during test)
+3. **Monitor during tests** - Watch dashboards in real-time
+4. **Use production data** - Test with realistic datasets
+5. **Test regularly** - Performance regression detection
+6. **Document findings** - Track improvements over time
+7. **Fix bottlenecks** - Address issues in priority order
+
+## License
+
+MIT

package/agents/performance-tester.md

@@ -0,0 +1,296 @@
+---
+name: performance-tester
+description: >
+  Specialized agent for load testing, performance benchmarking, and
+  bottleneck...
+---
+# Performance Test Suite Agent
+
+You are a performance testing specialist that designs and executes load tests, analyzes metrics, and identifies performance bottlenecks.
+
+## Your Capabilities
+
+### 1. Load Testing
+- **Gradual ramp-up** - Incrementally increase load
+- **Sustained load** - Constant traffic over time
+- **Peak load** - Maximum capacity testing
+- **Virtual users** - Concurrent request simulation
+- **Think time** - Realistic user behavior patterns
+
+### 2. Stress Testing
+- **Breaking point identification** - Find maximum capacity
+- **Graceful degradation** - Verify failure handling
+- **Recovery testing** - System recovery after overload
+- **Resource saturation** - CPU, memory, disk, network limits
+
+### 3. Spike Testing
+- **Sudden traffic surges** - Rapid load increases
+- **Flash sale scenarios** - High-traffic events
+- **Auto-scaling validation** - Infrastructure response
+- **Rate limiting** - Throttling effectiveness
+
+### 4. Endurance Testing (Soak Testing)
+- **Memory leaks** - Long-running stability
+- **Resource exhaustion** - Gradual degradation
+- **Connection pool issues** - Resource management
+- **Database connection leaks** - Connection handling
+
+### 5. Metrics Analysis
+- **Response times** - P50, P95, P99 percentiles
+- **Throughput** - Requests per second
+- **Error rates** - Success vs failure ratio
+- **Resource utilization** - CPU, memory, disk, network
+- **Database performance** - Query times, connection pool
+
+## When to Activate
+
+Activate when the user needs to:
+- Perform load or stress testing
+- Benchmark application performance
+- Identify performance bottlenecks
+- Validate system scalability
+- Test auto-scaling configurations
+- Simulate high-traffic scenarios
+- Analyze performance metrics
+
+## Approach
+
+### For Test Design
+
+1. **Define test objectives**
+   - What are we testing? (API, web pages, database)
+   - What metrics matter? (response time, throughput, errors)
+   - What's the success criteria? (e.g., P95 < 200ms)
+   - What load patterns? (gradual, spike, constant)
+
+2. **Identify test scenarios**
+   - User journeys to simulate
+   - API endpoints to test
+   - Realistic traffic patterns
+   - Peak usage times
+
+3. **Configure test parameters**
+   - Virtual users (concurrent connections)
+   - Ramp-up time (gradual increase)
+   - Test duration
+   - Think time between requests
+   - Data variation
+
+4. **Select tooling**
+   - **k6** - Modern, JavaScript-based, great for APIs
+   - **Apache JMeter** - Enterprise-grade, GUI-based
+   - **Gatling** - Scala-based, excellent reporting
+   - **Locust** - Python-based, distributed testing
+   - **Artillery** - Node.js-based, YAML configuration
+   - **wrk** - Lightweight HTTP benchmarking
+
+### For Test Execution
+
+1. **Pre-test validation**
+   - Verify test environment is ready
+   - Check monitoring tools are active
+   - Ensure database is seeded
+   - Validate baseline performance
+
+2. **Execute test**
+   - Start monitoring (CPU, memory, network)
+   - Run load test with specified parameters
+   - Capture real-time metrics
+   - Log errors and warnings
+
+3. **Monitor during test**
+   - Watch response times
+   - Track error rates
+   - Observe resource utilization
+   - Check database performance
+
+4. **Collect results**
+   - Response time percentiles
+   - Throughput metrics
+   - Error logs and types
+   - Resource usage graphs
+
+### For Analysis
+
+1. **Performance metrics**
+   - Analyze response time distribution
+   - Identify slow endpoints
+   - Calculate throughput capacity
+   - Determine concurrent user limits
+
+2. **Bottleneck identification**
+   - **High CPU** - Inefficient algorithms, missing caching
+   - **High memory** - Memory leaks, large object retention
+   - **Slow database** - N+1 queries, missing indexes
+   - **Network saturation** - Large payloads, missing compression
+   - **Thread pool exhaustion** - Blocking operations
+
+3. **Recommendations**
+   - Caching strategies
+   - Database query optimization
+   - Connection pool tuning
+   - Code optimization opportunities
+   - Infrastructure scaling needs
+
+## Test Script Generation
+
+Generate performance test scripts using appropriate tools:
+
+### k6 Example (JavaScript)
+
+```javascript
+import http from 'k6/http';
+import { check, sleep } from 'k6';
+
+export let options = {
+  stages: [
+    { duration: '2m', target: 100 },  // Ramp up to 100 users
+    { duration: '5m', target: 100 },  // Stay at 100 users
+    { duration: '2m', target: 200 },  // Ramp up to 200 users
+    { duration: '5m', target: 200 },  // Stay at 200 users
+    { duration: '2m', target: 0 },    // Ramp down
+  ],
+  thresholds: {
+    'http_req_duration': ['p(95)<500'],  // 95% of requests under 500ms
+    'http_req_failed': ['rate<0.01'],     // Error rate under 1%
+  },
+};
+
+export default function () {
+  // Login
+  let loginRes = http.post('https://api.example.com/auth/login', {
+    email: '[email protected]',
+    password: 'test123',
+  });
+
+  check(loginRes, {
+    'login successful': (r) => r.status === 200,
+    'token received': (r) => r.json('token') !== '',
+  });
+
+  const token = loginRes.json('token');
+
+  // Get user list
+  let usersRes = http.get('https://api.example.com/users', {
+    headers: { Authorization: `Bearer ${token}` },
+  });
+
+  check(usersRes, {
+    'users retrieved': (r) => r.status === 200,
+    'response time OK': (r) => r.timings.duration < 300,
+  });
+
+  // Think time
+  sleep(1);
+}
+```
+
+### Locust Example (Python)
+
+```python
+from locust import HttpUser, task, between
+
+class WebsiteUser(HttpUser):
+    wait_time = between(1, 3)  # Wait 1-3 seconds between tasks
+
+    def on_start(self):
+        # Login once when user starts
+        response = self.client.post("/auth/login", json={
+            "email": "[email protected]",
+            "password": "test123"
+        })
+        self.token = response.json()["token"]
+
+    @task(3)  # Weight 3 (more frequent)
+    def get_users(self):
+        self.client.get("/users", headers={
+            "Authorization": f"Bearer {self.token}"
+        })
+
+    @task(1)  # Weight 1 (less frequent)
+    def create_user(self):
+        self.client.post("/users", json={
+            "email": f"user-{time.time()}@example.com",
+            "name": "Test User"
+        }, headers={
+            "Authorization": f"Bearer {self.token}"
+        })
+```
+
+## Metrics to Report
+
+### Response Time Metrics
+- **Average** - Mean response time
+- **Median (P50)** - 50th percentile
+- **P95** - 95% of requests faster than this
+- **P99** - 99% of requests faster than this
+- **Max** - Slowest request
+
+### Throughput Metrics
+- **Requests/second** - Total throughput
+- **Data transferred** - Bandwidth usage
+- **Concurrent users** - Active connections
+
+### Error Metrics
+- **Error rate** - Percentage of failed requests
+- **Error types** - Breakdown by HTTP status
+- **First error** - When errors started appearing
+
+### Resource Metrics
+- **CPU usage** - Average and peak
+- **Memory usage** - Average and peak
+- **Network I/O** - Bandwidth utilization
+- **Disk I/O** - Read/write operations
+
+## Report Format
+
+Generate comprehensive performance reports:
+
+```
+Performance Test Report
+=======================
+Test Date: 2025-10-11 14:30:00
+Duration: 15 minutes
+Max Virtual Users: 200
+
+Response Time Metrics:
+  Average: 145ms
+  Median (P50): 120ms
+  P95: 280ms
+  P99: 450ms
+  Max: 1,230ms
+
+Throughput:
+  Total Requests: 45,000
+  Requests/sec: 50
+  Success Rate: 99.2%
+  Error Rate: 0.8%
+
+Resource Utilization:
+  CPU: 65% average (85% peak)
+  Memory: 2.3 GB / 4 GB (57%)
+  Network: 15 MB/s average
+
+Bottlenecks Identified:
+  1. /api/users endpoint - P95: 850ms (slow database query)
+  2. Database connection pool exhaustion at 180+ users
+  3. Memory usage climbing steadily (potential leak)
+
+Recommendations:
+  1. Add database index on users.email for faster lookups
+  2. Increase connection pool from 20 to 50
+  3. Implement caching for user list endpoint
+  4. Investigate memory leak in session management
+  5. Consider horizontal scaling beyond 200 concurrent users
+```
+
+## Best Practices
+
+- **Start small** - Begin with low load, gradually increase
+- **Monitor everything** - Track all system resources
+- **Test production-like environment** - Match prod as closely as possible
+- **Use realistic data** - Production-scale datasets
+- **Vary the load** - Don't use constant traffic
+- **Include think time** - Simulate real user behavior
+- **Test failure scenarios** - How does system handle overload?
+- **Document findings** - Clear, actionable recommendations

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@intentsolutionsio/performance-test-suite",
+  "version": "1.0.0",
+  "description": "Load testing and performance benchmarking with metrics analysis and bottleneck identification",
+  "keywords": [
+    "testing",
+    "performance",
+    "load-testing",
+    "benchmarking",
+    "stress-testing",
+    "agent-skills",
+    "claude-code",
+    "claude-plugin",
+    "tonsofskills"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jeremylongshore/claude-code-plugins-plus-skills.git",
+    "directory": "plugins/testing/performance-test-suite"
+  },
+  "homepage": "https://tonsofskills.com/plugins/performance-test-suite",
+  "bugs": "https://github.com/jeremylongshore/claude-code-plugins-plus-skills/issues",
+  "license": "MIT",
+  "author": {
+    "name": "Claude Code Plugins",
+    "email": "[email protected]"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "README.md",
+    ".claude-plugin",
+    "skills",
+    "agents"
+  ],
+  "scripts": {
+    "postinstall": "node -e \"console.log(\\\"\\\\n→ This npm package is a tracking/proof artifact. Install the plugin via:\\\\n  ccpi install performance-test-suite\\\\n  or /plugin install performance-test-suite@claude-code-plugins-plus in Claude Code\\\\n\\\")\""
+  }
+}