opencode-skills-collection 3.1.12 → 3.1.14

package/bundled-skills/incremental-implementation/SKILL.md

@@ -0,0 +1,262 @@
+---
+name: incremental-implementation
+description: Delivers changes incrementally. Use when implementing any feature or change that touches more than one file. Use when you're about to write a large amount of code at once, or when a task feels too big to land in one step.
+risk: unknown
+source: https://github.com/addyosmani/agent-skills/tree/main/skills/incremental-implementation
+source_repo: addyosmani/agent-skills
+source_type: community
+date_added: 2026-07-01
+license: MIT
+license_source: https://github.com/addyosmani/agent-skills/blob/main/LICENSE
+---
+
+# Incremental Implementation
+
+## Overview
+
+Build in thin vertical slices — implement one piece, test it, verify it, then expand. Avoid implementing an entire feature in one pass. Each increment should leave the system in a working, testable state. This is the execution discipline that makes large features manageable.
+
+## When to Use
+
+- Implementing any multi-file change
+- Building a new feature from a task breakdown
+- Refactoring existing code
+- Any time you're tempted to write more than ~100 lines before testing
+
+**When NOT to use:** Single-file, single-function changes where the scope is already minimal.
+
+## The Increment Cycle
+
+```
+┌──────────────────────────────────────┐
+│                                      │
+│   Implement ──→ Test ──→ Verify ──┐  │
+│       ▲                           │  │
+│       └───── Commit ◄─────────────┘  │
+│              │                       │
+│              ▼                       │
+│          Next slice                  │
+│                                      │
+└──────────────────────────────────────┘
+```
+
+For each slice:
+
+1. **Implement** the smallest complete piece of functionality
+2. **Test** — run the test suite (or write a test if none exists)
+3. **Verify** — confirm the slice works as expected (tests pass, build succeeds, manual check)
+4. **Commit** -- save your progress with a descriptive message (see `git-workflow-and-versioning` for atomic commit guidance)
+5. **Move to the next slice** — carry forward, don't restart
+
+## Slicing Strategies
+
+### Vertical Slices (Preferred)
+
+Build one complete path through the stack:
+
+```
+Slice 1: Create a task (DB + API + basic UI)
+    → Tests pass, user can create a task via the UI
+
+Slice 2: List tasks (query + API + UI)
+    → Tests pass, user can see their tasks
+
+Slice 3: Edit a task (update + API + UI)
+    → Tests pass, user can modify tasks
+
+Slice 4: Delete a task (delete + API + UI + confirmation)
+    → Tests pass, full CRUD complete
+```
+
+Each slice delivers working end-to-end functionality.
+
+### Contract-First Slicing
+
+When backend and frontend need to develop in parallel:
+
+```
+Slice 0: Define the API contract (types, interfaces, OpenAPI spec)
+Slice 1a: Implement backend against the contract + API tests
+Slice 1b: Implement frontend against mock data matching the contract
+Slice 2: Integrate and test end-to-end
+```
+
+### Risk-First Slicing
+
+Tackle the riskiest or most uncertain piece first:
+
+```
+Slice 1: Prove the WebSocket connection works (highest risk)
+Slice 2: Build real-time task updates on the proven connection
+Slice 3: Add offline support and reconnection
+```
+
+If Slice 1 fails, you discover it before investing in Slices 2 and 3.
+
+## Implementation Rules
+
+### Rule 0: Simplicity First
+
+Before writing any code, ask: "What is the simplest thing that could work?"
+
+After writing code, review it against these checks:
+- Can this be done in fewer lines?
+- Are these abstractions earning their complexity?
+- Would a staff engineer look at this and say "why didn't you just..."?
+- Am I building for hypothetical future requirements, or the current task?
+
+```
+SIMPLICITY CHECK:
+✗ Generic EventBus with middleware pipeline for one notification
+✓ Simple function call
+
+✗ Abstract factory pattern for two similar components
+✓ Two straightforward components with shared utilities
+
+✗ Config-driven form builder for three forms
+✓ Three form components
+```
+
+Three similar lines of code is better than a premature abstraction. Implement the naive, obviously-correct version first. Optimize only after correctness is proven with tests.
+
+### Rule 0.5: Scope Discipline
+
+Touch only what the task requires.
+
+Do NOT:
+- "Clean up" code adjacent to your change
+- Refactor imports in files you're not modifying
+- Remove comments you don't fully understand
+- Add features not in the spec because they "seem useful"
+- Modernize syntax in files you're only reading
+
+If you notice something worth improving outside your task scope, note it — don't fix it:
+
+```
+NOTICED BUT NOT TOUCHING:
+- src/utils/format.ts has an unused import (unrelated to this task)
+- The auth middleware could use better error messages (separate task)
+→ Want me to create tasks for these?
+```
+
+### Rule 1: One Thing at a Time
+
+Each increment changes one logical thing. Don't mix concerns:
+
+**Bad:** One commit that adds a new component, refactors an existing one, and updates the build config.
+
+**Good:** Three separate commits — one for each change.
+
+### Rule 2: Keep It Compilable
+
+After each increment, the project must build and existing tests must pass. Don't leave the codebase in a broken state between slices.
+
+### Rule 3: Feature Flags for Incomplete Features
+
+If a feature isn't ready for users but you need to merge increments:
+
+```typescript
+// Feature flag for work-in-progress
+const ENABLE_TASK_SHARING = process.env.FEATURE_TASK_SHARING === 'true';
+
+if (ENABLE_TASK_SHARING) {
+  // New sharing UI
+}
+```
+
+This lets you merge small increments to the main branch without exposing incomplete work.
+
+### Rule 4: Safe Defaults
+
+New code should default to safe, conservative behavior:
+
+```typescript
+// Safe: disabled by default, opt-in
+export function createTask(data: TaskInput, options?: { notify?: boolean }) {
+  const shouldNotify = options?.notify ?? false;
+  // ...
+}
+```
+
+### Rule 5: Rollback-Friendly
+
+Each increment should be independently revertable:
+
+- Additive changes (new files, new functions) are easy to revert
+- Modifications to existing code should be minimal and focused
+- Database migrations should have corresponding rollback migrations
+- Avoid deleting something in one commit and replacing it in the same commit — separate them
+
+## Working with Agents
+
+When directing an agent to implement incrementally:
+
+```
+"Let's implement Task 3 from the plan.
+
+Start with just the database schema change and the API endpoint.
+Don't touch the UI yet — we'll do that in the next increment.
+
+After implementing, run `npm test` and `npm run build` to verify
+nothing is broken."
+```
+
+Be explicit about what's in scope and what's NOT in scope for each increment.
+
+## Increment Checklist
+
+After each increment, verify:
+
+- [ ] The change does one thing and does it completely
+- [ ] All existing tests still pass (`npm test`)
+- [ ] The build succeeds (`npm run build`)
+- [ ] Type checking passes (`npx tsc --noEmit`)
+- [ ] Linting passes (`npm run lint`)
+- [ ] The new functionality works as expected
+- [ ] The change is committed with a descriptive message
+
+**Note:** Run each verification command after a change that could affect it. After a successful run, don't repeat the same command unless the code has changed since — re-running on unchanged code adds no information.
+
+## Common Rationalizations
+
+| Rationalization | Reality |
+|---|---|
+| "I'll test it all at the end" | Bugs compound. A bug in Slice 1 makes Slices 2-5 wrong. Test each slice. |
+| "It's faster to do it all at once" | It *feels* faster until something breaks and you can't find which of 500 changed lines caused it. |
+| "These changes are too small to commit separately" | Small commits are free. Large commits hide bugs and make rollbacks painful. |
+| "I'll add the feature flag later" | If the feature isn't complete, it shouldn't be user-visible. Add the flag now. |
+| "This refactor is small enough to include" | Refactors mixed with features make both harder to review and debug. Separate them. |
+| "Let me run the build command again just to be sure" | After a successful run, repeating the same command adds nothing unless the code has changed since. Run it again after subsequent edits, not as reassurance. |
+
+## Red Flags
+
+- More than 100 lines of code written without running tests
+- Multiple unrelated changes in a single increment
+- "Let me just quickly add this too" scope expansion
+- Skipping the test/verify step to move faster
+- Build or tests broken between increments
+- Large uncommitted changes accumulating
+- Building abstractions before the third use case demands it
+- Touching files outside the task scope "while I'm here"
+- Creating new utility files for one-time operations
+- Running the same build/test command twice in a row without any intervening code change
+
+## Verification
+
+After completing all increments for a task:
+
+- [ ] Each increment was individually tested and committed
+- [ ] The full test suite passes
+- [ ] The build is clean
+- [ ] The feature works end-to-end as specified
+- [ ] No uncommitted changes remain
+
+## See Also
+
+Per-increment verification is the local check. Before declaring a task done, apply the project-wide Definition of Done as the final gate, the standing bar every increment clears regardless of the task. See `references/definition-of-done.md`.
+
+## 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/jest-skill/SKILL.md

@@ -0,0 +1,182 @@
+---
+name: jest-skill
+description: 'Generates Jest unit and integration tests in JavaScript or TypeScript. Covers mocking, snapshots, async testing, and React component testing. Use when user mentions "Jest", "describe/it/expect", "jest.mock", "toMatchSnapshot". Triggers on: "Jest", "expect().toBe()", "jest.mock",...'
+risk: unknown
+source: https://github.com/LambdaTest/agent-skills/tree/main/jest-skill
+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
+---
+
+# Jest Testing Skill
+## When to Use
+
+Use this skill when you need generates Jest unit and integration tests in JavaScript or TypeScript. Covers mocking, snapshots, async testing, and React component testing. Use when user mentions "Jest", "describe/it/expect", "jest.mock", "toMatchSnapshot". Triggers on: "Jest", "expect().toBe()", "jest.mock",...
+
+
+## Core Patterns
+
+### Basic Test
+
+```javascript
+describe('Calculator', () => {
+  let calc;
+  beforeEach(() => { calc = new Calculator(); });
+
+  test('adds two numbers', () => {
+    expect(calc.add(2, 3)).toBe(5);
+  });
+
+  test('throws on division by zero', () => {
+    expect(() => calc.divide(10, 0)).toThrow('Division by zero');
+  });
+});
+```
+
+### Matchers
+
+```javascript
+expect(value).toBe(exact);                 // === strict
+expect(value).toEqual(object);             // deep equality
+expect(value).toBeTruthy();
+expect(value).toBeNull();
+expect(value).toBeGreaterThan(3);
+expect(value).toBeCloseTo(0.3, 5);
+expect(str).toMatch(/regex/);
+expect(arr).toContain(item);
+expect(arr).toHaveLength(3);
+expect(obj).toHaveProperty('name');
+expect(obj).toMatchObject({ name: 'Alice' });
+expect(() => fn()).toThrow(CustomError);
+```
+
+### Mocking
+
+```javascript
+// Mock function
+const mockFn = jest.fn();
+mockFn.mockReturnValue(42);
+mockFn.mockResolvedValue({ data: 'test' });
+expect(mockFn).toHaveBeenCalledWith('arg1');
+expect(mockFn).toHaveBeenCalledTimes(1);
+
+// Mock module
+jest.mock('./database');
+const db = require('./database');
+db.getUser.mockResolvedValue({ name: 'Alice' });
+
+// Mock with implementation
+jest.mock('./api', () => ({
+  fetchUsers: jest.fn().mockResolvedValue([{ name: 'Alice' }]),
+}));
+
+// Spy
+const spy = jest.spyOn(console, 'log').mockImplementation();
+expect(spy).toHaveBeenCalledWith('expected');
+spy.mockRestore();
+
+// Fake timers
+jest.useFakeTimers();
+jest.advanceTimersByTime(1000);
+jest.useRealTimers();
+```
+
+### Async Testing
+
+```javascript
+test('fetches users', async () => {
+  const users = await fetchUsers();
+  expect(users).toHaveLength(3);
+});
+
+test('resolves with data', () => {
+  return expect(fetchData()).resolves.toEqual({ data: 'value' });
+});
+
+test('rejects with error', () => {
+  return expect(fetchBadData()).rejects.toThrow('not found');
+});
+```
+
+### React Component Testing (Testing Library)
+
+```javascript
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import LoginForm from './LoginForm';
+
+test('submits login form', async () => {
+  const onSubmit = jest.fn();
+  render(<LoginForm onSubmit={onSubmit} />);
+
+  fireEvent.change(screen.getByLabelText('Email'), {
+    target: { value: 'user@test.com' },
+  });
+  fireEvent.change(screen.getByLabelText('Password'), {
+    target: { value: 'password123' },
+  });
+  fireEvent.click(screen.getByRole('button', { name: /login/i }));
+
+  await waitFor(() => {
+    expect(onSubmit).toHaveBeenCalledWith({
+      email: 'user@test.com', password: 'password123',
+    });
+  });
+});
+```
+
+### Snapshot Testing
+
+```javascript
+test('renders correctly', () => {
+  const tree = renderer.create(<Button label="Click" />).toJSON();
+  expect(tree).toMatchSnapshot();
+});
+// Update: jest --updateSnapshot
+```
+
+### Anti-Patterns
+
+| Bad | Good | Why |
+|-----|------|-----|
+| `expect(x === y).toBe(true)` | `expect(x).toBe(y)` | Better errors |
+| No `await` on async | Always `await` | Swallows failures |
+| Snapshot everything | Snapshot UI, assert logic | Snapshot fatigue |
+
+## Quick Reference
+
+| Task | Command |
+|------|---------|
+| Run all | `npx jest` |
+| Watch | `npx jest --watch` |
+| Coverage | `npx jest --coverage` |
+| Update snapshots | `npx jest --updateSnapshot` |
+| Run file | `npx jest tests/calc.test.js` |
+| Single test | `test.only('name', () => {})` |
+
+## Deep Patterns
+
+For production-grade patterns, see `reference/playbook.md`:
+
+| Section | What's Inside |
+|---------|--------------|
+| §1 Production Config | Node + React configs, path aliases, coverage thresholds |
+| §2 Mocking Deep Dive | Module/partial/manual mocks, spies, timers, env vars |
+| §3 Async Patterns | Promises, rejections, event emitters, streams |
+| §4 test.each | Array, tagged template, describe.each for table-driven tests |
+| §5 Custom Matchers | toBeWithinRange, toBeValidEmail, TypeScript declarations |
+| §6 React Testing Library | userEvent, hooks, context providers |
+| §7 Snapshot Testing | Component, inline, property matchers |
+| §8 API Service Testing | Mocked axios, CRUD patterns, error handling |
+| §9 Global Setup | Multi-project config, DB setup/teardown |
+| §10 CI/CD | GitHub Actions with coverage gates |
+| §11 Debugging Table | 10 common problems with fixes |
+| §12 Best Practices | 15-item production checklist |
+
+## 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/junit-5-skill/SKILL.md

@@ -0,0 +1,236 @@
+---
+name: junit-5-skill
+description: Generates production-grade JUnit 5 unit and integration tests in Java. Covers assertions, parameterized tests, lifecycle hooks, mocking with Mockito, and nested tests. Use when user mentions "JUnit", "JUnit 5", "@Test", "assertEquals", "Assertions", "Java unit test". Triggers on:...
+risk: unknown
+source: https://github.com/LambdaTest/agent-skills/tree/main/junit-5-skill
+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
+---
+
+# JUnit 5 Testing Skill
+## When to Use
+
+Use this skill when you need generates production-grade JUnit 5 unit and integration tests in Java. Covers assertions, parameterized tests, lifecycle hooks, mocking with Mockito, and nested tests. Use when user mentions "JUnit", "JUnit 5", "@Test", "assertEquals", "Assertions", "Java unit test". Triggers on:...
+
+
+You are a senior Java developer specializing in JUnit 5 testing.
+
+## Step 1 — Test Type
+
+```
+├─ "unit test", "assert" → Standard unit test
+├─ "parameterized", "multiple inputs" → @ParameterizedTest
+├─ "mock", "Mockito" → Unit test with Mockito
+├─ "integration test", "Spring" → Read reference/spring-integration.md
+└─ Default → Standard unit test
+```
+
+## Core Patterns
+
+### Basic Test
+
+```java
+import org.junit.jupiter.api.*;
+import static org.junit.jupiter.api.Assertions.*;
+
+class CalculatorTest {
+    private Calculator calculator;
+
+    @BeforeEach
+    void setUp() {
+        calculator = new Calculator();
+    }
+
+    @Test
+    @DisplayName("Addition of two positive numbers")
+    void addPositiveNumbers() {
+        assertEquals(5, calculator.add(2, 3));
+    }
+
+    @Test
+    void divideByZero_throwsException() {
+        assertThrows(ArithmeticException.class, () -> calculator.divide(10, 0));
+    }
+
+    @Test
+    void multipleAssertions() {
+        assertAll("calculator operations",
+            () -> assertEquals(4, calculator.add(2, 2)),
+            () -> assertEquals(0, calculator.subtract(2, 2)),
+            () -> assertEquals(6, calculator.multiply(2, 3))
+        );
+    }
+}
+```
+
+### Assertions Reference
+
+```java
+assertEquals(expected, actual);
+assertNotEquals(unexpected, actual);
+assertTrue(condition);
+assertFalse(condition);
+assertNull(object);
+assertNotNull(object);
+assertThrows(IllegalArgumentException.class, () -> service.process(null));
+assertTimeout(Duration.ofSeconds(2), () -> service.longRunningOp());
+assertAll("group",
+    () -> assertNotNull(user.getName()),
+    () -> assertTrue(user.getAge() > 0)
+);
+assertIterableEquals(List.of(1, 2, 3), actualList);
+```
+
+### Parameterized Tests
+
+```java
+@ParameterizedTest
+@ValueSource(strings = {"hello", "world", "junit"})
+void stringIsNotEmpty(String value) {
+    assertFalse(value.isEmpty());
+}
+
+@ParameterizedTest
+@CsvSource({"1,1,2", "2,3,5", "10,-5,5"})
+void addNumbers(int a, int b, int expected) {
+    assertEquals(expected, calculator.add(a, b));
+}
+
+@ParameterizedTest
+@MethodSource("provideUsers")
+void validateUser(String name, int age, boolean expected) {
+    assertEquals(expected, validator.isValid(name, age));
+}
+
+static Stream<Arguments> provideUsers() {
+    return Stream.of(
+        Arguments.of("Alice", 25, true),
+        Arguments.of("", 25, false),
+        Arguments.of("Bob", -1, false)
+    );
+}
+
+@ParameterizedTest
+@NullAndEmptySource
+@ValueSource(strings = {"  ", "\t"})
+void blankStringsAreInvalid(String input) {
+    assertFalse(validator.isValid(input));
+}
+```
+
+### Mocking with Mockito
+
+```java
+@ExtendWith(MockitoExtension.class)
+class UserServiceTest {
+    @Mock private UserRepository userRepo;
+    @Mock private EmailService emailService;
+    @InjectMocks private UserService userService;
+
+    @Test
+    void createUser_savesAndSendsEmail() {
+        User user = new User("alice@test.com", "Alice");
+        when(userRepo.save(any(User.class))).thenReturn(user);
+
+        User result = userService.createUser("alice@test.com", "Alice");
+
+        assertNotNull(result);
+        verify(userRepo).save(any(User.class));
+        verify(emailService).sendWelcomeEmail("alice@test.com");
+    }
+
+    @Test
+    void getUser_notFound_throwsException() {
+        when(userRepo.findById(99L)).thenReturn(Optional.empty());
+        assertThrows(UserNotFoundException.class, () -> userService.getUser(99L));
+    }
+}
+```
+
+### Nested Tests
+
+```java
+@DisplayName("UserService")
+class UserServiceTest {
+    @Nested
+    @DisplayName("when creating a user")
+    class CreateUser {
+        @Test void withValidData_succeeds() { }
+        @Test void withDuplicateEmail_throwsException() { }
+    }
+
+    @Nested
+    @DisplayName("when deleting a user")
+    class DeleteUser {
+        @Test void existingUser_removesFromDb() { }
+        @Test void nonExistentUser_throwsException() { }
+    }
+}
+```
+
+### Anti-Patterns
+
+| Bad | Good | Why |
+|-----|------|-----|
+| `@Test public void test1()` | `@Test void shouldCalculateSum()` | Descriptive names |
+| Testing private methods | Test via public API | Implementation detail |
+| No @DisplayName | Always add display names | Better reporting |
+| `assertEquals(true, x)` | `assertTrue(x)` | More readable |
+
+## Maven Dependencies
+
+```xml
+<dependency>
+    <groupId>org.junit.jupiter</groupId>
+    <artifactId>junit-jupiter</artifactId>
+    <version>5.11.0</version>
+    <scope>test</scope>
+</dependency>
+<dependency>
+    <groupId>org.mockito</groupId>
+    <artifactId>mockito-junit-jupiter</artifactId>
+    <version>5.14.0</version>
+    <scope>test</scope>
+</dependency>
+```
+
+## Quick Reference
+
+| Task | Command |
+|------|---------|
+| Run all | `mvn test` or `./gradlew test` |
+| Run class | `mvn test -Dtest=UserServiceTest` |
+| Run method | `mvn test -Dtest=UserServiceTest#createUser_succeeds` |
+| Run tagged | `@Tag("slow")` + `mvn test -Dgroups="slow"` |
+| Disable | `@Disabled("Reason")` |
+| Conditional | `@EnabledOnOs(OS.LINUX)` |
+| Timeout | `@Timeout(value = 5, unit = TimeUnit.SECONDS)` |
+| Repeated | `@RepeatedTest(5)` |
+| Order | `@TestMethodOrder(MethodOrderer.OrderAnnotation.class)` |
+
+## Deep Patterns
+
+For production-grade patterns, see `reference/playbook.md`:
+
+| Section | What's Inside |
+|---------|--------------|
+| §1 Project Setup | Maven deps, parallel config, surefire |
+| §2 Test Lifecycle | BeforeAll/Each, ordering, tags |
+| §3 Parameterized | CsvSource, MethodSource, EnumSource, ValueSource |
+| §4 Mockito | @Mock/@InjectMocks, captor, verify order |
+| §5 Nested & Dynamic | @Nested grouping, @TestFactory |
+| §6 AssertJ | Fluent assertions, extracting, collection checks |
+| §7 Conditional | @EnabledOnOs, assumptions, @EnabledIf |
+| §8 Custom Extensions | Timing, retry, BeforeTestExecution |
+| §9 CI/CD | GitHub Actions with test reporter |
+| §10 Debugging Table | 8 common problems with fixes |
+| §11 Best Practices | 12-item production checklist |
+
+## 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.