@jmylchreest/aide-plugin 0.0.24 → 0.0.26

package/skills/test/SKILL.md

@@ -0,0 +1,244 @@
+---
+name: test
+description: Write and run tests for code
+triggers:
+  - "write tests"
+  - "add tests"
+  - "test this"
+  - "run tests"
+---
+
+# Test Mode
+
+**Recommended model tier:** balanced (sonnet) - this skill performs straightforward operations
+
+Write comprehensive tests and run test suites.
+
+## Prerequisites
+
+Before starting:
+- Identify the code to be tested (function, module, feature)
+- Understand the testing framework used in the project
+
+## Workflow
+
+### Step 1: Check Project Testing Decisions
+
+Use the `mcp__plugin_aide_aide__decision_get` tool with topic `testing` to check for testing framework decisions.
+
+Common frameworks by language:
+- **TypeScript/JavaScript:** Vitest, Jest, Mocha
+- **Go:** built-in `go test`
+- **Python:** pytest, unittest
+
+### Step 2: Discover Existing Test Patterns
+
+Use `Glob` to find test files:
+- Pattern: `**/*.test.ts`, `**/*.spec.ts` (TypeScript)
+- Pattern: `**/*_test.go` (Go)
+- Pattern: `**/test_*.py`, `**/*_test.py` (Python)
+
+Use `mcp__plugin_aide_aide__code_search` with query `describe` and `it` to find test patterns.
+
+Read an existing test file to understand:
+- Import patterns
+- Setup/teardown patterns
+- Mocking approach
+- Assertion style
+
+### Step 3: Analyze Target Code
+
+Use `mcp__plugin_aide_aide__code_symbols` with the target file path to get function signatures.
+Use `mcp__plugin_aide_aide__code_search` to find related types.
+
+Identify:
+- Input parameters and types
+- Return type
+- Side effects
+- Dependencies to mock
+- Edge cases
+
+### Step 4: Write Tests
+
+Follow the project's testing conventions. Cover these scenarios:
+
+**Test Categories:**
+1. **Happy path** - Normal, expected inputs
+2. **Edge cases** - Empty, null, boundary values
+3. **Error cases** - Invalid inputs, expected failures
+4. **Async behavior** - If applicable
+
+**Naming convention:**
+- Descriptive names that explain what is being tested
+- Format: "should [expected behavior] when [condition]"
+
+### Step 5: Run Tests
+
+```bash
+# TypeScript/JavaScript
+npm test                    # Run all tests
+npm test -- --grep "name"   # Run specific test
+npm run test:coverage       # Run with coverage
+
+# Go
+go test ./...               # Run all tests
+go test -v ./pkg/...        # Verbose output
+go test -cover ./...        # With coverage
+
+# Python
+pytest                      # Run all tests
+pytest -v                   # Verbose
+pytest --cov                # With coverage
+```
+
+### Step 6: Verify Coverage
+
+```bash
+# Check coverage report
+npm run test:coverage
+
+# Go
+go test -coverprofile=coverage.out ./...
+go tool cover -html=coverage.out
+```
+
+**Coverage targets:**
+- New code: aim for >80%
+- Critical paths: aim for >90%
+- Focus on meaningful tests, not just coverage numbers
+
+## Failure Handling
+
+| Failure | Action |
+|---------|--------|
+| Test imports fail | Check path aliases, ensure test config matches main |
+| Mock not working | Verify mock setup, check dependency injection |
+| Async test timeout | Add proper await, increase timeout if needed |
+| Flaky test | Check for shared state, timing issues, or external deps |
+| Coverage too low | Add edge case tests, error path tests |
+
+## Test Structure Templates
+
+### TypeScript/JavaScript (Vitest/Jest)
+
+```typescript
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { functionToTest } from './module';
+
+describe('functionToTest', () => {
+  beforeEach(() => {
+    // Reset state before each test
+    vi.clearAllMocks();
+  });
+
+  it('should return expected result for valid input', () => {
+    const result = functionToTest('valid input');
+    expect(result).toBe('expected output');
+  });
+
+  it('should handle empty input', () => {
+    const result = functionToTest('');
+    expect(result).toBe('');
+  });
+
+  it('should throw error for null input', () => {
+    expect(() => functionToTest(null)).toThrow('Input required');
+  });
+
+  it('should handle async operation', async () => {
+    const result = await functionToTest('async input');
+    expect(result).resolves.toBe('async output');
+  });
+});
+```
+
+### Go
+
+```go
+func TestFunctionName(t *testing.T) {
+    tests := []struct {
+        name    string
+        input   string
+        want    string
+        wantErr bool
+    }{
+        {"valid input", "input", "expected", false},
+        {"empty input", "", "", false},
+        {"invalid input", "bad", "", true},
+    }
+
+    for _, tt := range tests {
+        t.Run(tt.name, func(t *testing.T) {
+            got, err := FunctionName(tt.input)
+            if (err != nil) != tt.wantErr {
+                t.Errorf("error = %v, wantErr %v", err, tt.wantErr)
+                return
+            }
+            if got != tt.want {
+                t.Errorf("got = %v, want %v", got, tt.want)
+            }
+        })
+    }
+}
+```
+
+### Python
+
+```python
+import pytest
+from module import function_to_test
+
+class TestFunctionToTest:
+    def test_valid_input(self):
+        assert function_to_test("input") == "expected"
+
+    def test_empty_input(self):
+        assert function_to_test("") == ""
+
+    def test_invalid_input_raises(self):
+        with pytest.raises(ValueError):
+            function_to_test(None)
+
+    @pytest.fixture
+    def mock_dependency(self, mocker):
+        return mocker.patch("module.dependency")
+```
+
+## MCP Tools
+
+- `mcp__plugin_aide_aide__code_search` - Find existing tests, patterns, types
+- `mcp__plugin_aide_aide__code_symbols` - Understand function signatures to test
+- `mcp__plugin_aide_aide__decision_get` - Check testing framework decisions
+
+## Verification Criteria
+
+Before completing:
+- [ ] All new tests pass
+- [ ] Existing tests still pass
+- [ ] Coverage meets project standards
+- [ ] Tests are deterministic (not flaky)
+- [ ] Tests follow project conventions
+
+## Output Format
+
+```markdown
+## Tests Added
+
+### Files
+- `path/to/file.test.ts` - 5 tests for UserService
+
+### Test Cases
+1. should create user with valid data
+2. should reject duplicate email
+3. should hash password before saving
+4. should handle empty name
+5. should validate email format
+
+### Coverage
+- New code: 92%
+- Total project: 84%
+
+### Verification
+- All tests: PASS
+- No flaky tests observed
+```

package/skills/verify/SKILL.md

@@ -0,0 +1,299 @@
+---
+name: verify
+description: Active QA verification - full validation before completion
+triggers:
+  - verify this
+  - verify the
+  - qa check
+  - validate
+  - verification
+  - verify stage
+---
+
+# Verify Mode
+
+**Recommended model tier:** smart (opus) - this skill requires complex reasoning
+
+Active QA verification: run all quality checks and report pass/fail status.
+
+## Purpose
+
+This is the VERIFY stage of the SDLC pipeline. Implementation is complete. Your job is to run comprehensive validation and report results.
+
+**This is different from `review`**: Review is read-only analysis. Verify is active execution of quality checks.
+
+## Verification Checklist
+
+Run ALL of the following. Each must pass.
+
+### 1. Full Test Suite
+
+```bash
+# TypeScript/JavaScript
+npm test
+
+# Go
+go test ./...
+
+# Python
+pytest
+```
+
+**Expected**: All tests pass, no failures, no skipped tests.
+
+### 2. Type Checking
+
+```bash
+# TypeScript
+npx tsc --noEmit
+
+# Go (implicit in build)
+go build ./...
+
+# Python (if using mypy)
+mypy .
+```
+
+**Expected**: No type errors.
+
+### 3. Linting
+
+```bash
+# TypeScript/JavaScript
+npm run lint
+
+# Go
+go vet ./...
+golangci-lint run
+
+# Python
+ruff check .
+```
+
+**Expected**: No lint errors. Warnings acceptable if pre-existing.
+
+### 4. Build
+
+```bash
+# TypeScript/JavaScript
+npm run build
+
+# Go
+go build ./...
+
+# Python
+python -m py_compile *.py
+```
+
+**Expected**: Build succeeds without errors.
+
+### 5. Debug Artifact Check
+
+Search for common debug artifacts that shouldn't be committed:
+
+```bash
+# Console logs (JS/TS)
+Grep for "console.log" in changed files
+
+# Debug prints (Go)
+Grep for "fmt.Println" or "log.Print" that look like debug
+
+# Python debug
+Grep for "print(" or "pdb" or "breakpoint()"
+
+# TODO/FIXME comments
+Grep for "TODO" or "FIXME" in changed files
+
+# Debugger statements
+Grep for "debugger" in JS/TS files
+```
+
+**Expected**: No debug artifacts in new code. Pre-existing ones noted but not blocking.
+
+### 6. Uncommitted Changes Check
+
+```bash
+git status
+```
+
+**Expected**: Working directory clean, or only expected files modified.
+
+## Workflow
+
+### Step 1: Run All Checks
+
+Execute each check in sequence, capturing output:
+
+```bash
+# Run all checks, capture results
+npm test 2>&1 | head -50
+npm run lint 2>&1 | head -50
+npx tsc --noEmit 2>&1 | head -50
+npm run build 2>&1 | head -50
+```
+
+### Step 2: Check for Debug Artifacts
+
+```bash
+# Search for debug code in recently changed files
+git diff --name-only HEAD~1 | xargs grep -l "console.log\|debugger" 2>/dev/null || true
+```
+
+### Step 3: Compile Results
+
+Create a verification report.
+
+## Output Format
+
+### All Checks Pass
+
+```markdown
+## Verification Report: PASS
+
+### Tests
+- Status: PASS
+- Total: 42
+- Passed: 42
+- Failed: 0
+
+### Type Check
+- Status: PASS
+- Errors: 0
+
+### Lint
+- Status: PASS
+- Errors: 0
+- Warnings: 3 (pre-existing)
+
+### Build
+- Status: PASS
+
+### Debug Artifacts
+- Status: CLEAN
+- No debug code found in new files
+
+### Verdict: READY FOR DOCS STAGE
+```
+
+### Some Checks Fail
+
+```markdown
+## Verification Report: FAIL
+
+### Tests
+- Status: FAIL
+- Total: 42
+- Passed: 40
+- Failed: 2
+- Failures:
+  - `UserService.test.ts:45` - expected 200, got 401
+  - `AuthMiddleware.test.ts:23` - timeout after 5000ms
+
+### Type Check
+- Status: PASS
+
+### Lint
+- Status: FAIL
+- Errors:
+  - `src/user.ts:12` - 'unused' is defined but never used
+
+### Build
+- Status: PASS
+
+### Debug Artifacts
+- Status: WARNING
+- Found:
+  - `src/user.ts:34` - console.log("debug user:", user)
+
+### Verdict: NEEDS BUILD-FIX
+
+Issues to resolve:
+1. Fix 2 failing tests
+2. Remove console.log on line 34
+3. Fix lint error (remove unused variable)
+```
+
+## Failure Handling
+
+### Tests Fail
+
+1. Document which tests fail and why
+2. Do NOT fix them yourself (that's BUILD-FIX stage (via `/aide:build-fix`))
+3. Report failures clearly
+4. Verdict: FAIL, needs BUILD-FIX stage (via `/aide:build-fix`)
+
+### Lint Errors
+
+1. Document all lint errors
+2. Distinguish new errors from pre-existing
+3. New errors = FAIL
+4. Pre-existing warnings = PASS with notes
+
+### Type Errors
+
+1. Document all type errors with file:line
+2. Always FAIL on type errors
+3. Type errors must be fixed before proceeding
+
+### Build Fails
+
+1. Document build error
+2. Always FAIL on build errors
+3. Critical blocker for release
+
+## Decision Tree
+
+```
+All tests pass?
+├── No → FAIL (needs BUILD-FIX)
+└── Yes → Type check pass?
+          ├── No → FAIL (needs BUILD-FIX)
+          └── Yes → Lint pass?
+                    ├── No (new errors) → FAIL (needs BUILD-FIX)
+                    └── Yes/Warnings only → Build pass?
+                                           ├── No → FAIL (needs BUILD-FIX)
+                                           └── Yes → Debug artifacts?
+                                                     ├── Found → FAIL (needs cleanup)
+                                                     └── Clean → PASS
+```
+
+## Completion
+
+### On PASS
+
+```
+Verification complete: ALL CHECKS PASS
+Ready for DOCS stage.
+```
+
+### On FAIL
+
+```
+Verification complete: CHECKS FAILED
+Returning to BUILD-FIX stage (via `/aide:build-fix`).
+
+Issues:
+1. [list of issues]
+```
+
+When FAIL, the BUILD-FIX stage (via `/aide:build-fix`) addresses issues, then VERIFY runs again.
+
+## Integration with SDLC Pipeline
+
+```
+[DESIGN] → [TEST] → [DEV] → [VERIFY] → [DOCS]
+                               ↑
+                          YOU ARE HERE
+                               │
+                    ┌──────────┴──────────┐
+                    │                     │
+                  PASS                  FAIL
+                    │                     │
+                    ▼                     ▼
+                 [DOCS]               [BUILD-FIX] → [VERIFY]
+```
+
+- **Input**: Completed implementation from DEV stage
+- **Output**: Pass/Fail report with specifics
+- **On Pass**: Proceed to DOCS stage
+- **On Fail**: Return to BUILD-FIX stage (via `/aide:build-fix`), then re-verify