anchi-kit 1.2.0 → 1.2.2

package/.antigravity/skills/subagent-driven-development/SKILL.md

@@ -0,0 +1,237 @@
+---
+name: subagent-driven-development
+description: Subagent-Driven Development (SADD) methodology for dispatching independent subagents to handle individual tasks with code review checkpoints between iterations. Enables rapid, controlled parallel development with quality gates.
+---
+
+# Subagent-Driven Development (SADD)
+
+Parallel development workflow using independent subagents with built-in quality checkpoints.
+
+## When to Use
+
+- Large features requiring multiple parallel workstreams
+- Complex systems with independent components
+- When development velocity is critical
+- Projects with clear component boundaries
+- Teams practicing modular architecture
+
+## Core Concept
+
+**Break → Dispatch → Review → Integrate**
+
+Instead of one agent doing everything sequentially, dispatch multiple specialized subagents to work in parallel, with mandatory code review checkpoints between iterations.
+
+## SADD Workflow
+
+### 1. Task Decomposition
+
+Break feature into independent, parallelizable tasks:
+
+```
+Feature: User Authentication System
+↓
+Subagents:
+1. Database schema + migration
+2. API endpoints + validation
+3. Frontend forms + state
+4. Email verification service
+5. Session management
+6. Security audit
+```
+
+**Key:** Each task must be completable independently
+
+### 2. Subagent Dispatch
+
+Create independent subagent for each task:
+
+```markdown
+## Subagent 1: Database Schema
+
+**Scope:** User table, indexes, migration scripts
+**Deliverables:**
+
+- migration files
+- model definitions
+- unit tests
+  **Dependencies:** None
+  **Checkpoint:** Schema review before proceeding
+```
+
+### 3. Code Review Checkpoints
+
+**MANDATORY** review before next iteration:
+
+```
+Iteration 1 (Implementation)
+  ↓
+CHECKPOINT (Code Review)
+  ↓
+Iteration 2 (Refinement)
+  ↓
+CHECKPOINT (Integration Review)
+  ↓
+Merge
+```
+
+**Checkpoint Criteria:**
+
+- Code quality standards met
+- Tests passing
+- Documentation complete
+- No architectural violations
+- Security reviewed
+
+### 4. Parallel Execution
+
+Multiple subagents work simultaneously:
+
+```
+t=0: Dispatch 6 subagents
+t=1: All working in parallel
+t=2: Checkpoints (reviews happen)
+t=3: Continue or iterate
+t=4: Integration phase
+```
+
+## Best Practices
+
+1. **Clear Boundaries** - Each subagent owns distinct scope
+2. **Explicit Dependencies** - Document what depends on what
+3. **Quality Gates** - Never skip checkpoints
+4. **Communication** - Subagents report status regularly
+5. **Integration Plan** - Know how pieces fit together
+
+## Subagent Task Template
+
+```markdown
+# Subagent: [Name]
+
+## Scope
+
+- [What this subagent is responsible for]
+
+## Deliverables
+
+- [ ] File 1
+- [ ] File 2
+- [ ] Tests
+- [ ] Documentation
+
+## Dependencies
+
+- Requires: [Other subagent outputs]
+- Provides: [What others need from this]
+
+## Checkpoint Criteria
+
+- [ ] Code quality: passed linting
+- [ ] Tests: 100% passing
+- [ ] Security: reviewed
+- [ ] Documentation: complete
+
+## Status
+
+- [ ] Planning
+- [ ] Implementation
+- [ ] Review
+- [ ] Complete
+```
+
+## Example: E-Commerce Feature
+
+**Feature:** Product Recommendations
+
+**Decomposition:**
+
+```
+Subagent A: Data Pipeline
+→ Fetch user behavior data
+→ Process purchase history
+→ Generate feature vectors
+
+Subagent B: ML Model
+→ Train recommendation model
+→ Test accuracy (>85%)
+→ Export model artifacts
+
+Subagent C: API Service
+→ REST endpoint /recommendations
+→ Model inference
+→ Response caching
+
+Subagent D: Frontend Component
+→ Recommendation widget
+→ Click tracking
+→ A/B test integration
+```
+
+**Parallel Timeline:**
+
+```
+Day 1: All 4 subagents start
+Day 2: Checkpoint reviews
+Day 3: Refinements
+Day 4: Integration testing
+Day 5: Production deploy
+```
+
+**Sequential would take:** ~10-15 days  
+**SADD approach:** ~5 days
+
+## Integration Strategy
+
+### Incremental Integration
+
+```
+1. Integrate A + B → Test
+2. Integrate C → Test
+3. Integrate D → Test
+4. Full system test
+```
+
+### Conflict Resolution
+
+When subagents conflict:
+
+1. **Identify:** Which boundary was violated?
+2. **Discuss:** Why did conflict happen?
+3. **Resolve:** Adjust boundaries or merge approach
+4. **Document:** Update task decomposition
+
+## Anti-Patterns
+
+❌ **Too Fine-Grained**
+
+- Don't create subagent for every single file
+- Minimum: 1 day of work per subagent
+
+❌ **Skipping Checkpoints**
+
+- Never merge without review
+- Quality gates are mandatory
+
+❌ **Unclear Dependencies**
+
+- Document all dependencies upfront
+- Update as discovered
+
+❌ **No Integration Plan**
+
+- Know how pieces fit together
+- Test integration frequently
+
+## References
+
+See [references/subagent-patterns.md](references/subagent-patterns.md) for:
+
+- Advanced decomposition strategies
+- Checkpoint review templates
+- Integration testing patterns
+- Communication protocols
+
+See [references/code-review-checkpoints.md](references/code-review-checkpoints.md) for:
+
+- Review criteria checklists
+- Quality gate definitions
+- Automated checkpoint validation

package/.antigravity/skills/test-driven-development/SKILL.md

@@ -0,0 +1,130 @@
+---
+name: test-driven-development
+description: Test-Driven Development workflow for implementing features and bugfixes. Use when implementing any feature or bugfix, before writing implementation code. Guides developers through the red-green-refactor cycle with best practices.
+---
+
+# Test-Driven Development
+
+Implements Test-Driven Development (TDD) methodology - write tests first, then implementation.
+
+## When to Use
+
+- Implementing any new feature
+- Fixing bugs
+- Refactoring existing code
+- When user requests TDD workflow
+- Before writing implementation code
+
+## TDD Workflow (Red-Green-Refactor)
+
+### 1. Red - Write Failing Test
+
+Write a test that defines desired behavior:
+
+```javascript
+// Example: test/user.test.js
+describe("User", () => {
+  it("should create user with email", () => {
+    const user = new User({ email: "test@example.com" });
+    expect(user.email).toBe("test@example.com");
+  });
+});
+```
+
+**Run test** - it should fail (red)
+
+### 2. Green - Make It Pass
+
+Write minimal code to make test pass:
+
+```javascript
+// src/user.js
+class User {
+  constructor({ email }) {
+    this.email = email;
+  }
+}
+```
+
+**Run test again** - it should pass (green)
+
+### 3. Refactor - Clean Up
+
+Improve code quality while keeping tests green:
+
+- Remove duplication
+- Improve naming
+- Extract functions
+- Optimize performance
+
+**Run tests** - should still pass
+
+## Best Practices
+
+1. **One Test at a Time** - Focus on one behavior per test
+2. **Small Steps** - Write small, incremental tests
+3. **Test Behavior, Not Implementation** - Test what, not how
+4. **Keep Tests Fast** - Tests should run in milliseconds
+5. **Independent Tests** - Each test should be isolated
+6. **Clear Test Names** - Describe expected behavior
+
+## Test Structure (AAA Pattern)
+
+```javascript
+it("should validate email format", () => {
+  // Arrange - Setup test data
+  const invalidEmail = "not-an-email";
+
+  // Act - Execute the behavior
+  const result = validateEmail(invalidEmail);
+
+  // Assert - Verify the outcome
+  expect(result.valid).toBe(false);
+});
+```
+
+## Common Testing Patterns
+
+See [references/tdd-patterns.md](references/tdd-patterns.md) for:
+
+- Unit testing patterns
+- Integration testing approaches
+- Mocking strategies
+- Test data builders
+
+## Testing Strategies
+
+See [references/testing-strategies.md](references/testing-strategies.md) for:
+
+- Frontend component testing
+- API endpoint testing
+- Database interaction testing
+- Error handling tests
+- Edge case identification
+
+## Framework Examples
+
+### Jest (JavaScript/TypeScript)
+
+```bash
+npm install --save-dev jest @types/jest
+npx jest --watch
+```
+
+### Pytest (Python)
+
+```bash
+pip install pytest
+pytest --watch
+```
+
+### Go Testing
+
+```bash
+go test ./... -v
+```
+
+## References
+
+- [TDD Patterns](references/tdd-patterns.md) - Common TDD patterns
+- [Testing Strategies](references/testing-strategies.md) - Strategies for different scenarios

package/.antigravity/skills/test-fixing/SKILL.md

@@ -0,0 +1,256 @@
+---
+name: test-fixing
+description: Automatically detect failing tests, analyze failure patterns, and propose high-confidence fixes. Speeds up debugging by identifying root causes and suggesting patches with detailed explanations.
+---
+
+# Test Fixing
+
+Automated test failure detection and repair with intelligent root cause analysis.
+
+## When to Use
+
+- Tests failing in CI/CD
+- After refactoring breaks tests
+- Flaky test debugging
+- Integration test failures
+- Before claiming work complete
+
+## Quick Detection
+
+### Identify Failing Tests
+
+```bash
+# Run tests and capture failures
+npm test 2>&1 | tee test-output.txt
+
+# Or
+pytest --tb=short -v > test-results.txt
+```
+
+**AI analyzes:**
+
+- Which tests failed
+- Failure messages
+- Stack traces
+- Recent code changes
+
+## Failure Pattern Analysis
+
+### Common Patterns
+
+**1. Assertion Failures**
+
+```javascript
+Expected: 200
+Received: 404
+
+→ Likely: API endpoint changed or route not registered
+```
+
+**2. Timeout Errors**
+
+```
+Error: Timeout of 2000ms exceeded
+
+→ Likely: Async operation not awaited or slow external call
+```
+
+**3. Undefined Errors**
+
+```
+TypeError: Cannot read property 'id' of undefined
+
+→ Likely: Missing null check or data structure changed
+```
+
+**4. Mock Issues**
+
+```
+Mock called 0 times, expected 1
+
+→ Likely: Code path changed or mock not properly set up
+```
+
+## Auto-Fix Proposal
+
+### Confidence Scoring
+
+AI proposes fixes with confidence levels:
+
+**High Confidence (90%+)**
+
+```diff
+- const user = users.find(u => u.id === id);
++ const user = users.find(u => u.id === id) || null;
+  return user.name;
++ if (!user) return null;
++ return user.name;
+```
+
+**Medium Confidence (60-89%)**
+
+```diff
+Possible fix 1:
+- await fetch('/api/users')
++ await fetch('/api/v2/users')
+
+Possible fix 2:
+Update mock to match new endpoint
+```
+
+**Low Confidence (<60%)**
+
+```
+Need more information:
+- Check if API endpoint moved
+- Verify response structure
+- Review recent API changes
+```
+
+## Fix Workflow
+
+### 1. Analyze Failure
+
+```markdown
+Test: "should create user"
+Status: FAILED
+Error: Expected 201, got 500
+
+Analysis:
+
+- Server returning 500 (Internal Server Error)
+- Likely database constraint violation
+- Recent change: added password validation
+```
+
+### 2. Propose Fix
+
+```diff
+File: src/user-service.js
+
+- const user = await db.users.create({ email, name });
++ const user = await db.users.create({
++   email,
++   name,
++   password: hashedPassword // Missing required field
++ });
+```
+
+### 3. Validate Fix
+
+```bash
+# Apply patch
+git apply proposed-fix.patch
+
+# Re-run test
+npm test -- user-service.test.js
+
+# Verify: PASSED ✅
+```
+
+### 4. Regression Prevention
+
+Add test for the issue:
+
+```javascript
+it("should require password when creating user", async () => {
+  await expect(
+    createUser({ email: "test@example.com", name: "Test" })
+  ).rejects.toThrow("Password is required");
+});
+```
+
+## Advanced Patterns
+
+### Flaky Test Detection
+
+Identify tests that fail intermittently:
+
+```javascript
+// Run test 100 times
+for (let i = 0; i < 100; i++) {
+  await runTest("flaky-test");
+}
+
+// Analyze: Failed 23/100 times
+// Pattern: Fails when data contains special characters
+// Fix: Improve data sanitization
+```
+
+### Integration Test Fixes
+
+When integration tests fail:
+
+1. **Check external dependencies**
+
+   - Database running?
+   - API server up?
+   - Mock services configured?
+
+2. **Verify test data**
+
+   - Seed data correct?
+   - Test fixtures up to date?
+   - Cleanup between tests?
+
+3. **Review test order**
+   - Tests independent?
+   - No shared state?
+   - Proper isolation?
+
+## CI/CD Integration
+
+### Automated Fix Suggestions
+
+```yaml
+# .github/workflows/test-fix.yml
+on: [pull_request]
+jobs:
+  test-and-suggest-fixes:
+    runs-on: ubuntu-latest
+    steps:
+      - run: npm test || true
+      - run: node scripts/analyze-test-failures.js
+      - run: node scripts/suggest-fixes.js
+      - uses: actions/github-script@v6
+        with:
+          script: |
+            // Post fix suggestions as PR comment
+```
+
+## Best Practices
+
+1. **Run Tests First** - Always get fresh failure data
+2. **Understand Before Fixing** - Don't blindly apply fixes
+3. **One Fix at a Time** - Apply and test incrementally
+4. **Add Regression Tests** - Prevent same failure
+5. **Document** - Explain why test failed and how fixed
+
+## Common Test Failures
+
+### Unit Tests
+
+- **Mocking issues** → Verify mock setup
+- **Assertion errors** → Check expected vs actual values
+- **Setup/teardown** → Ensure clean state
+
+### Integration Tests
+
+- **Timing issues** → Add proper waits
+- **State pollution** → Improve test isolation
+- **External services** → Use test doubles
+
+### E2E Tests
+
+- **Element not found** → Update selectors
+- **Timeouts** → Increase wait times
+- **Flakiness** → Improve stability
+
+## References
+
+See [references/test-repair-patterns.md](references/test-repair-patterns.md) for:
+
+- Common failure patterns catalog
+- Fix templates by test framework
+- Debugging strategies
+- Regression prevention techniques

package/.antigravity/skills/theme-factory/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: theme-factory
+description: Apply professional font and color themes to artifacts including slides, docs, reports, and HTML pages. 10 pre-set themes for consistent branding and aesthetics.
+---
+
+# Theme Factory
+
+Professional themes for consistent design across artifacts.
+
+## When to Use
+
+- Applying brand colors
+- Creating presentations
+- Styling documents
+- Professional reports
+- Landing pages
+
+## Pre-Set Themes
+
+1. **Corporate Blue** - Professional, trustworthy
+2. **Vibrant Startup** - Energetic, modern
+3. **Minimal Dark** - Sleek, sophisticated
+4. **Nature Green** - Calm, eco-friendly
+5. **Sunset Orange** - Warm, creative
+6. **Ocean Teal** - Fresh, innovative
+7. **Royal Purple** - Luxury, premium
+8. **Monochrome** - Classic, timeless
+9. **Pastel Dream** - Soft, friendly
+10. **Tech Neon** - Futuristic, bold
+
+## Theme Application
+
+```css
+/* Corporate Blue Theme */
+:root {
+  --primary: #1e40af;
+  --secondary: #3b82f6;
+  --accent: #60a5fa;
+  --background: #f8fafc;
+  --text: #1e293b;
+
+  --font-heading: "Inter", sans-serif;
+  --font-body: "Open Sans", sans-serif;
+}
+```
+
+## Usage
+
+```html
+<div class="theme-corporate-blue">
+  <h1>Professional Heading</h1>
+  <p>Body text with consistent styling</p>
+</div>
+```
+
+## Components
+
+- Color palettes
+- Font pairings
+- Spacing scales
+- Component styles
+
+See [assets/theme-presets.json](assets/theme-presets.json) for all themes.