opencode-goopspec 0.1.0

package/skills/task-decomposition/skill.md

@@ -0,0 +1,153 @@
+---
+name: task-decomposition
+description: Break down complex tasks into manageable units
+category: core
+triggers:
+  - decompose
+  - breakdown
+  - split
+  - tasks
+version: 0.1.0
+requires:
+  - goop-core
+---
+
+# Task Decomposition Skill
+
+## Decomposition Principles
+
+### 1. Single Responsibility
+Each task does one thing well.
+
+### 2. Independently Testable
+Each task can be verified in isolation.
+
+### 3. Clear Boundaries
+No ambiguity about where one task ends and another begins.
+
+### 4. Reasonable Size
+Tasks should take 15-60 minutes, not hours or days.
+
+### 5. Dependency Awareness
+Identify genuine dependencies, avoid false chains.
+
+## Decomposition Process
+
+### Step 1: Identify the Goal
+What is the end state? What problem are we solving?
+
+### Step 2: List Major Components
+What are the big pieces that make up the solution?
+
+### Step 3: Break Into Tasks
+For each component, what specific work items exist?
+
+### Step 4: Identify Dependencies
+Which tasks must complete before others can start?
+
+### Step 5: Estimate Complexity
+Rate each task: Small (15m), Medium (30m), Large (60m)
+
+### Step 6: Group Into Waves
+Parallel tasks in same wave, sequential across waves.
+
+## Task Granularity Guide
+
+### Too Large
+❌ "Implement authentication system"
+
+### Just Right
+✓ "Create user model with password hashing"
+✓ "Implement login endpoint"
+✓ "Add session management"
+✓ "Write authentication tests"
+
+### Too Small
+❌ "Add email field to user model"
+❌ "Import bcrypt library"
+
+## Task Format
+
+```xml
+<task type="auto">
+### Task 1: {Verb + Object}
+
+**Description:**
+{2-3 sentences explaining what and why}
+
+**Files:**
+- `path/to/file.ts`
+
+**Verify:**
+```bash
+npm test -- --testPathPattern=feature
+```
+
+**Done:**
+- [ ] Criterion 1
+- [ ] Criterion 2
+</task>
+```
+
+## Dependency Types
+
+### Hard Dependency
+Task B literally cannot start until Task A completes.
+```
+Task A: Create database schema
+Task B: Implement repository (needs schema)
+```
+
+### Soft Dependency
+Task B is easier if Task A completes first, but not required.
+```
+Task A: Set up linting
+Task B: Implement feature (can work without linting)
+```
+
+### No Dependency
+Tasks are completely independent.
+```
+Task A: Implement auth
+Task B: Implement logging
+```
+
+## Wave Planning
+
+```
+Wave 1: Foundation (no dependencies)
+├── Setup project structure
+├── Configure database
+└── Set up testing framework
+
+Wave 2: Core Features (depends on Wave 1)
+├── Implement user model
+├── Implement auth endpoints
+└── Implement session management
+
+Wave 3: Integration (depends on Wave 2)
+├── Connect frontend to auth
+└── Write E2E tests
+```
+
+## Anti-Patterns
+
+### Kitchen Sink Task
+❌ Task includes too many unrelated items.
+
+### Vague Task
+❌ "Make it work" or "Fix the thing"
+
+### Circular Dependencies
+❌ Task A needs B, Task B needs A.
+
+### Premature Optimization
+❌ "Optimize database queries" before queries exist.
+
+## Best Practices
+
+1. **Start with verifiable tasks** - If you can't verify it, it's too vague
+2. **Vertical slices** - Complete user-visible features
+3. **Front-load risks** - Tackle uncertain tasks early
+4. **Include verification** - Every task has a "done" check
+5. **Buffer time** - Plan 80% capacity, leave room for surprises

package/skills/task-delegation/skill.md

@@ -0,0 +1,127 @@
+---
+name: task-delegation
+description: Patterns for delegating tasks to specialized agents
+category: core
+triggers:
+  - delegate
+  - spawn
+  - subagent
+  - task
+version: 0.1.0
+requires:
+  - goop-core
+---
+
+# Task Delegation Skill
+
+## When to Delegate
+
+Delegate when:
+- Task requires specialized expertise (testing, security, documentation)
+- Context is getting bloated (>70% usage)
+- Task can run in parallel with other work
+- Fresh perspective needed
+
+Don't delegate when:
+- Task is trivial (<5 minutes)
+- Heavy context sharing required
+- Sequential dependency on current work
+
+## Delegation Patterns
+
+### Sequential Delegation
+
+```json
+{
+  "mode": "sequential",
+  "tasks": [
+    { "agent": "planner", "task": "Create plan" },
+    { "agent": "executor", "task": "Implement plan" },
+    { "agent": "verifier", "task": "Verify implementation" }
+  ]
+}
+```
+
+### Parallel Delegation
+
+```json
+{
+  "mode": "parallel",
+  "max_concurrent": 3,
+  "tasks": [
+    { "agent": "executor", "task": "Implement feature A" },
+    { "agent": "executor", "task": "Implement feature B" },
+    { "agent": "tester", "task": "Write tests" }
+  ]
+}
+```
+
+### Background Delegation
+
+```json
+{
+  "mode": "background",
+  "agent": "researcher",
+  "task": "Research best practices",
+  "notify_on_complete": true
+}
+```
+
+## Agent Selection
+
+| Task Type | Agent | Model Tier |
+|-----------|-------|------------|
+| Planning | goop-planner | quality |
+| Implementation | goop-executor | balanced |
+| Verification | goop-verifier | quality |
+| Research | goop-researcher | balanced |
+| Documentation | goop-writer | budget |
+| Testing | goop-tester | balanced |
+| Debugging | goop-debugger | quality |
+| Security | goop-verifier | quality |
+
+## Context Handoff
+
+When delegating, pass:
+1. **Essential state:** Current phase, spec, todos
+2. **Relevant files:** Only files the agent needs
+3. **Recent decisions:** Last 3-5 ADL entries
+4. **Constraints:** Boundaries, deadlines, blockers
+
+Don't pass:
+- Full conversation history
+- Verbose logs
+- Unrelated file contents
+- Completed task details
+
+## Using task Tool
+
+```typescript
+task({
+  subagent_type: "general",
+  description: "Implement authentication",
+  prompt: `
+    ## TASK
+    Implement user authentication
+
+    ## CONTEXT
+    - SPEC: .goopspec/phases/phase-1/SPEC.md
+  `
+})
+```
+
+## Error Handling
+
+If delegated task fails:
+1. Check error type (timeout, crash, assertion)
+2. Save partial progress as checkpoint
+3. Decide: retry, reassign, or escalate
+4. Log failure to ADL if significant
+
+## Best Practices
+
+1. **Clear instructions:** Specific, unambiguous task descriptions
+2. **Scoped context:** Only relevant information
+3. **Defined success:** Clear verification criteria
+4. **Timeout limits:** Set reasonable time bounds
+5. **Progress tracking:** Monitor via todos/checkpoints

package/skills/technical-writing/skill.md

@@ -0,0 +1,69 @@
+---
+name: technical-writing
+description: Create clear, accurate, and useful technical documentation.
+category: docs
+triggers:
+  - writing
+  - documentation
+  - docs
+  - guide
+version: 0.1.0
+---
+
+# Technical Writing Skill
+
+## Purpose
+Create clear, accurate, and useful technical documentation.
+
+## Core Principles
+
+### 1. Know Your Audience
+- Who will read this?
+- What do they already know?
+- What do they need to accomplish?
+
+### 2. Be Clear and Concise
+- Use simple, direct language
+- One idea per sentence
+- Avoid jargon unless necessary
+
+### 3. Structure for Scanning
+- Use headings and subheadings
+- Include bullet points and lists
+- Add code examples
+- Use tables for comparisons
+
+### 4. Show, Don't Just Tell
+- Include working examples
+- Add screenshots where helpful
+- Provide step-by-step instructions
+
+## Document Types
+
+### Tutorials
+Step-by-step learning guides for beginners.
+
+### How-To Guides
+Task-oriented guides for specific goals.
+
+### Reference
+Comprehensive technical details and API docs.
+
+### Explanations
+Background and conceptual information.
+
+## Best Practices
+
+1. **Test Your Instructions** - Follow your own docs
+2. **Use Active Voice** - "Click the button" not "The button should be clicked"
+3. **Be Consistent** - Same terms, formatting, style throughout
+4. **Update Regularly** - Outdated docs are worse than none
+5. **Get Feedback** - Have users test your documentation
+
+## Checklist
+
+- [ ] Accurate and up-to-date?
+- [ ] Clear purpose stated upfront?
+- [ ] Prerequisites listed?
+- [ ] Examples are complete and working?
+- [ ] Proofread for errors?

package/skills/testing/skill.md

@@ -0,0 +1,202 @@
+---
+name: testing
+description: Write and run tests for implementations
+category: review
+triggers:
+  - test
+  - spec
+  - assert
+  - coverage
+version: 0.1.0
+requires:
+  - goop-core
+---
+
+# Testing Skill
+
+## Testing Pyramid
+
+```
+        /\
+       /  \        E2E Tests (Few)
+      /----\
+     /      \      Integration Tests (Some)
+    /--------\
+   /          \    Unit Tests (Many)
+  /------------\
+```
+
+## Test Types
+
+### Unit Tests
+Test individual functions in isolation.
+
+```typescript
+describe('validateEmail', () => {
+  it('accepts valid email', () => {
+    expect(validateEmail('user@example.com')).toBe(true);
+  });
+
+  it('rejects invalid email', () => {
+    expect(validateEmail('invalid')).toBe(false);
+  });
+});
+```
+
+### Integration Tests
+Test module interactions.
+
+```typescript
+describe('user registration', () => {
+  it('creates user and sends welcome email', async () => {
+    const user = await registerUser({ email: 'test@example.com' });
+    expect(user.id).toBeDefined();
+    expect(emailService.send).toHaveBeenCalled();
+  });
+});
+```
+
+### E2E Tests
+Test complete user flows.
+
+```typescript
+test('user can complete checkout', async ({ page }) => {
+  await page.goto('/products');
+  await page.click('[data-testid="add-to-cart"]');
+  await page.click('[data-testid="checkout"]');
+  await page.fill('#email', 'test@example.com');
+  await page.click('[data-testid="pay"]');
+  await expect(page).toHaveURL('/confirmation');
+});
+```
+
+## Test Structure (AAA)
+
+```typescript
+it('should do something', () => {
+  // Arrange
+  const input = { name: 'test' };
+  
+  // Act
+  const result = processInput(input);
+  
+  // Assert
+  expect(result.processed).toBe(true);
+});
+```
+
+## Mocking
+
+### Function Mocks
+```typescript
+const mockFetch = jest.fn().mockResolvedValue({ data: [] });
+```
+
+### Module Mocks
+```typescript
+jest.mock('./database', () => ({
+  query: jest.fn().mockResolvedValue([]),
+}));
+```
+
+### Time Mocks
+```typescript
+jest.useFakeTimers();
+jest.advanceTimersByTime(1000);
+```
+
+## Coverage Targets
+
+| Type | Target | Critical Path |
+|------|--------|---------------|
+| Statements | 80% | 95% |
+| Branches | 75% | 90% |
+| Functions | 80% | 95% |
+| Lines | 80% | 95% |
+
+## Test Commands
+
+```bash
+# Run all tests
+npm test
+
+# Run specific test file
+npm test -- --testPathPattern=auth
+
+# Run with coverage
+npm test -- --coverage
+
+# Watch mode
+npm test -- --watch
+
+# E2E tests
+npm run test:e2e
+```
+
+## Testing Best Practices
+
+### Do
+- One assertion per test (when possible)
+- Descriptive test names
+- Test behavior, not implementation
+- Use factories for test data
+- Clean up after tests
+
+### Don't
+- Test implementation details
+- Make tests depend on each other
+- Use magic numbers
+- Test third-party code
+- Ignore flaky tests
+
+## Test File Organization
+
+```
+src/
+├── auth/
+│   ├── login.ts
+│   └── __tests__/
+│       ├── login.test.ts
+│       └── login.integration.test.ts
+└── __tests__/
+    └── e2e/
+        └── auth.e2e.test.ts
+```
+
+## Fixtures
+
+```typescript
+// fixtures/users.ts
+export const validUser = {
+  id: '1',
+  email: 'test@example.com',
+  name: 'Test User',
+};
+
+export const invalidUser = {
+  id: '',
+  email: 'invalid',
+};
+```
+
+## Snapshot Testing
+
+```typescript
+it('renders correctly', () => {
+  const tree = render(<Button>Click me</Button>);
+  expect(tree).toMatchSnapshot();
+});
+```
+
+Update snapshots: `npm test -- -u`
+
+## Performance Testing
+
+```typescript
+it('completes within 100ms', async () => {
+  const start = performance.now();
+  await heavyOperation();
+  const duration = performance.now() - start;
+  expect(duration).toBeLessThan(100);
+});
+```

package/skills/ui-design/skill.md

@@ -0,0 +1,73 @@
+---
+name: ui-design
+description: Create user interfaces that are visually appealing, intuitive, and functional.
+category: design
+triggers:
+  - ui
+  - visual
+  - layout
+  - interface
+version: 0.1.0
+---
+
+# UI Design Skill
+
+## Purpose
+Create user interfaces that are visually appealing, intuitive, and functional.
+
+## Design Principles
+
+### 1. Hierarchy
+Guide users through content with visual importance.
+- Size: Larger = more important
+- Color: Bold/saturated = more important
+- Space: More whitespace = more important
+
+### 2. Consistency
+Use consistent patterns throughout.
+- Same colors mean same things
+- Same components behave the same
+- Predictable layouts
+
+### 3. Feedback
+Respond to user actions.
+- Hover states on interactive elements
+- Loading indicators for async operations
+- Success/error messages for actions
+
+### 4. Simplicity
+Remove unnecessary elements.
+- Every element should serve a purpose
+- Reduce cognitive load
+- Progressive disclosure for complexity
+
+## Color Usage
+
+| Color | Typical Use |
+|-------|-------------|
+| Primary | Main actions, branding |
+| Secondary | Supporting actions |
+| Success | Positive feedback (green) |
+| Warning | Caution (yellow/orange) |
+| Error | Problems (red) |
+| Neutral | Text, backgrounds, borders |
+
+## Typography
+
+- **Headlines** - Large, bold, limited use
+- **Body** - Readable, 16px minimum
+- **Captions** - Small, secondary information
+- **Line Height** - 1.5 for body text
+
+## Spacing System
+
+Use consistent spacing scale:
+`4px, 8px, 12px, 16px, 24px, 32px, 48px, 64px`
+
+## Component Checklist
+
+- [ ] Has visible focus state
+- [ ] Has hover state (if interactive)
+- [ ] Has disabled state
+- [ ] Works with keyboard
+- [ ] Has appropriate contrast

package/skills/ux-patterns/skill.md

@@ -0,0 +1,82 @@
+---
+name: ux-patterns
+description: Apply proven user experience patterns to create intuitive interfaces.
+category: design
+triggers:
+  - ux
+  - patterns
+  - usability
+  - interaction
+version: 0.1.0
+---
+
+# UX Patterns Skill
+
+## Purpose
+Apply proven user experience patterns to create intuitive interfaces.
+
+## Navigation Patterns
+
+### Global Navigation
+Top or side navigation for main sections.
+- Limit to 5-7 primary items
+- Highlight current section
+- Keep consistent across pages
+
+### Breadcrumbs
+Show location in hierarchy.
+- Use for deep hierarchies
+- Each item is clickable
+- Current page is not a link
+
+### Search
+Quick access to content.
+- Prominent placement
+- Autocomplete suggestions
+- Clear search button
+
+## Form Patterns
+
+### Inline Validation
+Validate as user types.
+- Show success for valid fields
+- Show errors after field blur
+- Don't validate empty required fields until submit
+
+### Progressive Disclosure
+Show fields progressively.
+- Start with essential fields
+- Reveal advanced options on demand
+- Group related fields
+
+### Smart Defaults
+Pre-fill sensible values.
+- Remember previous choices
+- Use location for regional defaults
+- Pre-select common options
+
+## Feedback Patterns
+
+### Loading States
+- Skeleton screens for initial load
+- Spinners for short waits (< 3s)
+- Progress bars for long operations
+- Optimistic updates when possible
+
+### Empty States
+- Explain what should be here
+- Guide user to add content
+- Don't just show "No items"
+
+### Error States
+- Explain what went wrong
+- Suggest how to fix it
+- Provide a path forward
+
+## Confirmation Patterns
+
+### Destructive Actions
+- Require explicit confirmation
+- Show what will be affected
+- Use different color (red) for danger
+- Allow undo when possible