opencode-goopspec 0.1.0

package/skills/parallel-planning/skill.md

@@ -0,0 +1,170 @@
+---
+name: parallel-planning
+description: Plan for parallel execution and wave-based scheduling
+category: core
+triggers:
+  - parallel
+  - wave
+  - concurrent
+  - batch
+version: 0.1.0
+requires:
+  - goop-core
+  - task-decomposition
+---
+
+# Parallel Planning Skill
+
+## Wave-Based Execution Model
+
+```
+Wave 1    Wave 2    Wave 3
+[A]       [C]       [F]
+[B]       [D]       
+          [E]       
+
+A,B parallel → C,D,E parallel → F sequential
+```
+
+## Identifying Parallelism
+
+### Independent Tasks
+Tasks with no shared:
+- Files being modified
+- Database tables being changed
+- External resources being accessed
+- State being mutated
+
+### Parallel Candidates
+- Different feature modules
+- Read-only operations
+- Documentation tasks
+- Test suites for different modules
+
+### Sequential Requirements
+- Schema migration before data access
+- Build before deploy
+- Tests before commit
+
+## Plan Frontmatter
+
+```yaml
+---
+phase: 1
+plan: feature-auth
+wave: 2
+depends_on: [setup-db, config-env]
+autonomous: true
+files_modified:
+  - src/auth/login.ts
+  - src/auth/session.ts
+---
+```
+
+## Wave Assignment Rules
+
+### Wave 1: Foundation
+- No external dependencies
+- Setup and configuration
+- Schema definitions
+
+### Wave 2: Core Implementation
+- Depends on Wave 1
+- Main feature development
+- Can be parallel within wave
+
+### Wave 3: Integration
+- Depends on Wave 2
+- Cross-cutting concerns
+- E2E tests
+
+### Wave N: Cleanup
+- Final polish
+- Documentation
+- Performance optimization
+
+## Conflict Detection
+
+### File Conflicts
+Two plans modifying same file cannot be parallel.
+
+```yaml
+# Plan A
+files_modified: [src/user.ts, src/auth.ts]
+
+# Plan B
+files_modified: [src/auth.ts, src/session.ts]
+
+# Conflict: src/auth.ts - must be sequential
+```
+
+### Resource Conflicts
+Two plans using same external resource.
+
+```yaml
+# Plan A: Migrate database
+# Plan B: Seed test data
+
+# Conflict: Both modify database - sequential
+```
+
+## Execution Strategies
+
+### Conservative (Default)
+- Maximum 2 parallel agents
+- Wait for wave completion
+- Checkpoint between waves
+
+### Aggressive
+- Maximum 4 parallel agents
+- Start next wave early when possible
+- Minimal checkpoints
+
+### Budget
+- Sequential execution only
+- Minimize resource usage
+- Maximum checkpoints
+
+## Using goop_wave_execute
+
+```typescript
+goop_wave_execute({
+  phase: "1",
+  gaps_only: false,
+  max_parallel: 3
+})
+```
+
+Response:
+```json
+{
+  "waves": [
+    {
+      "wave": 1,
+      "plans": ["setup-PLAN", "config-PLAN"],
+      "description": "Foundation setup"
+    },
+    {
+      "wave": 2,
+      "plans": ["auth-PLAN", "user-PLAN"],
+      "description": "Core features"
+    }
+  ]
+}
+```
+
+## Merge Strategy
+
+After parallel execution:
+1. Verify no conflicts in modified files
+2. Run all tests to catch integration issues
+3. Resolve any merge conflicts
+4. Create consolidated checkpoint
+
+## Best Practices
+
+1. **Conservative parallelism** - Start with 2 parallel, increase if stable
+2. **Clear boundaries** - No file overlap between parallel plans
+3. **Fail fast** - Stop wave on first failure
+4. **Checkpoint between waves** - Recovery points
+5. **Monitor resources** - Don't exceed API limits

package/skills/pattern-extraction/skill.md

@@ -0,0 +1,73 @@
+---
+name: pattern-extraction
+description: Identify recurring patterns and abstractions in a codebase for documentation and reuse.
+category: code
+triggers:
+  - patterns
+  - abstraction
+  - reuse
+  - refactor
+version: 0.1.0
+---
+
+# Pattern Extraction Skill
+
+## Purpose
+Identify recurring patterns and abstractions in a codebase for documentation and reuse.
+
+## Pattern Categories
+
+### 1. Structural Patterns
+- Module organization
+- Layer architecture
+- Feature-based structure
+- Shared utilities location
+
+### 2. Code Patterns
+- Error handling approach
+- Validation patterns
+- Data transformation patterns
+- API client patterns
+
+### 3. Testing Patterns
+- Test file organization
+- Mock/stub conventions
+- Fixture patterns
+- Integration test setup
+
+### 4. Component Patterns
+- Component composition
+- Prop patterns
+- State management
+- Event handling
+
+## Extraction Process
+
+1. **Sample Selection** - Choose representative files
+2. **Pattern Identification** - Note recurring structures
+3. **Validation** - Verify pattern is consistent across codebase
+4. **Documentation** - Write pattern description with examples
+5. **Counter-Examples** - Note exceptions and why they differ
+
+## Pattern Documentation Template
+
+```markdown
+## Pattern: [Name]
+
+### Intent
+What problem does this pattern solve?
+
+### Structure
+How is it organized?
+
+### Example
+```code
+// Representative example
+```
+
+### When to Use
+Guidelines for when to apply this pattern.
+
+### Variations
+Acceptable variations seen in codebase.
+```

package/skills/performance-optimization/skill.md

@@ -0,0 +1,188 @@
+---
+name: performance-optimization
+description: Optimize code and system performance
+category: optimization
+triggers:
+  - performance
+  - optimize
+  - speed
+  - memory
+version: 0.1.0
+requires:
+  - goop-core
+---
+
+# Performance Optimization Skill
+
+## Optimization Principles
+
+### 1. Measure First
+Never optimize without profiling data.
+
+### 2. Focus on Bottlenecks
+Optimize the slowest 20%, not everything.
+
+### 3. Maintain Readability
+Performance gains shouldn't sacrifice clarity.
+
+### 4. Test After Changes
+Verify optimizations don't break functionality.
+
+## Common Bottlenecks
+
+### Database
+- N+1 queries
+- Missing indexes
+- Unoptimized queries
+- Connection pool exhaustion
+
+### Network
+- Too many requests
+- Large payloads
+- Missing caching
+- Slow DNS resolution
+
+### CPU
+- Inefficient algorithms
+- Unnecessary computation
+- Blocking operations
+- Poor parallelization
+
+### Memory
+- Memory leaks
+- Large objects in memory
+- Unnecessary copies
+- Missing garbage collection
+
+## Profiling Tools
+
+### JavaScript/Node.js
+```bash
+# CPU profiling
+node --prof app.js
+node --prof-process isolate-*.log
+
+# Memory profiling
+node --inspect app.js
+# Open chrome://inspect
+
+# Benchmark
+npm install -g autocannon
+autocannon -c 100 -d 30 http://localhost:3000
+```
+
+### Database
+```sql
+-- PostgreSQL
+EXPLAIN ANALYZE SELECT * FROM users WHERE email = 'test@example.com';
+
+-- Add index
+CREATE INDEX idx_users_email ON users(email);
+```
+
+## Optimization Patterns
+
+### Caching
+```typescript
+const cache = new Map();
+
+async function getData(id: string) {
+  if (cache.has(id)) {
+    return cache.get(id);
+  }
+  const data = await fetchData(id);
+  cache.set(id, data);
+  return data;
+}
+```
+
+### Batching
+```typescript
+// Instead of N individual queries
+const users = await Promise.all(ids.map(id => getUser(id)));
+
+// Use batch query
+const users = await getUsersByIds(ids);
+```
+
+### Lazy Loading
+```typescript
+// Load only when needed
+const heavyModule = await import('./heavy-module');
+```
+
+### Pagination
+```typescript
+// Instead of loading all
+const users = await db.users.findMany({
+  skip: page * pageSize,
+  take: pageSize,
+});
+```
+
+## Performance Checklist
+
+### Frontend
+- [ ] Bundle size optimized
+- [ ] Images optimized
+- [ ] Code splitting implemented
+- [ ] Lazy loading for heavy components
+- [ ] Caching headers set
+
+### Backend
+- [ ] Database queries optimized
+- [ ] Proper indexes in place
+- [ ] Caching implemented
+- [ ] Connection pooling configured
+- [ ] Async operations used
+
+### Infrastructure
+- [ ] CDN configured
+- [ ] Compression enabled
+- [ ] HTTP/2 enabled
+- [ ] Geographic distribution
+
+## Metrics to Track
+
+| Metric | Target | Tool |
+|--------|--------|------|
+| Response time (p50) | <100ms | APM |
+| Response time (p99) | <500ms | APM |
+| Throughput | >1000 rps | Load test |
+| Error rate | <0.1% | APM |
+| Memory usage | <80% | Monitoring |
+| CPU usage | <70% | Monitoring |
+
+## Performance Report
+
+```markdown
+# Performance Analysis
+
+**Date:** {YYYY-MM-DD}
+**Scope:** {What was analyzed}
+
+## Current Performance
+{Baseline metrics}
+
+## Bottlenecks Identified
+1. {Bottleneck 1} - {Impact}
+2. {Bottleneck 2} - {Impact}
+
+## Optimizations Applied
+1. {Change 1} - {Improvement}
+2. {Change 2} - {Improvement}
+
+## Results
+{Before/after comparison}
+
+## Recommendations
+{Future improvements}
+```
+
+## Best Practices
+
+1. **Profile regularly** - Not just when slow
+2. **Set budgets** - Performance budgets for key metrics
+3. **Monitor production** - Lab != production
+4. **Automate testing** - CI performance tests
+5. **Document baselines** - Track trends over time

package/skills/playwright/skill.md

@@ -0,0 +1,69 @@
+---
+name: playwright
+description: Write effective end-to-end tests using Playwright for web applications.
+category: review
+triggers:
+  - playwright
+  - e2e
+  - browser
+  - testing
+version: 0.1.0
+---
+
+# Playwright Skill
+
+## Purpose
+Write effective end-to-end tests using Playwright for web applications.
+
+## Core Concepts
+
+### Page Object Model
+Encapsulate page interactions in reusable classes.
+
+```typescript
+class LoginPage {
+  constructor(private page: Page) {}
+  
+  async login(email: string, password: string) {
+    await this.page.fill('[data-testid="email"]', email);
+    await this.page.fill('[data-testid="password"]', password);
+    await this.page.click('[data-testid="submit"]');
+  }
+}
+```
+
+### Locator Strategies (Priority Order)
+1. `data-testid` attributes (most stable)
+2. Accessible roles and names
+3. Text content
+4. CSS selectors (least preferred)
+
+### Waiting Strategies
+- Auto-wait for elements (built-in)
+- `waitForSelector` for dynamic content
+- `waitForResponse` for API calls
+- `waitForLoadState` for navigation
+
+## Best Practices
+
+1. **Use Test IDs** - Add `data-testid` for test stability
+2. **Isolate Tests** - Each test should be independent
+3. **Mock Strategically** - Mock external services, not internal logic
+4. **Screenshot on Failure** - Capture state for debugging
+5. **Parallel Execution** - Use workers for speed
+
+## Common Patterns
+
+```typescript
+// Wait for API response
+await page.waitForResponse(resp => 
+  resp.url().includes('/api/users') && resp.status() === 200
+);
+
+// Screenshot on failure
+test.afterEach(async ({ page }, testInfo) => {
+  if (testInfo.status !== testInfo.expectedStatus) {
+    await page.screenshot({ path: `failure-${testInfo.title}.png` });
+  }
+});
+```

package/skills/playwright-testing/skill.md

@@ -0,0 +1,93 @@
+---
+name: playwright-testing
+description: Design and execute comprehensive Playwright test suites for web applications.
+category: review
+triggers:
+  - playwright
+  - testing
+  - e2e
+  - suites
+version: 0.1.0
+---
+
+# Playwright Testing Skill
+
+## Purpose
+Design and execute comprehensive Playwright test suites for web applications.
+
+## Test Organization
+
+```
+tests/
+  e2e/
+    auth/
+      login.spec.ts
+      signup.spec.ts
+    dashboard/
+      overview.spec.ts
+  fixtures/
+    auth.fixture.ts
+  pages/
+    login.page.ts
+    dashboard.page.ts
+```
+
+## Test Structure
+
+```typescript
+import { test, expect } from '@playwright/test';
+
+test.describe('Feature: User Login', () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto('/login');
+  });
+
+  test('should login with valid credentials', async ({ page }) => {
+    await page.fill('[data-testid="email"]', 'user@example.com');
+    await page.fill('[data-testid="password"]', 'password');
+    await page.click('[data-testid="submit"]');
+    await expect(page).toHaveURL('/dashboard');
+  });
+
+  test('should show error for invalid credentials', async ({ page }) => {
+    await page.fill('[data-testid="email"]', 'wrong@example.com');
+    await page.fill('[data-testid="password"]', 'wrong');
+    await page.click('[data-testid="submit"]');
+    await expect(page.locator('[data-testid="error"]')).toBeVisible();
+  });
+});
+```
+
+## Fixtures
+
+```typescript
+// fixtures/auth.fixture.ts
+import { test as base } from '@playwright/test';
+
+export const test = base.extend({
+  authenticatedPage: async ({ page }, use) => {
+    await page.goto('/login');
+    await page.fill('[data-testid="email"]', 'test@example.com');
+    await page.fill('[data-testid="password"]', 'password');
+    await page.click('[data-testid="submit"]');
+    await page.waitForURL('/dashboard');
+    await use(page);
+  },
+});
+```
+
+## Configuration
+
+```typescript
+// playwright.config.ts
+export default defineConfig({
+  testDir: './tests',
+  retries: 2,
+  workers: 4,
+  use: {
+    baseURL: 'http://localhost:3000',
+    trace: 'on-first-retry',
+    screenshot: 'only-on-failure',
+  },
+});
+```