anchi-kit 1.2.0 → 1.2.1

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-driven-development/references/tdd-patterns.md

@@ -0,0 +1,124 @@
+# TDD Patterns
+
+## Unit Testing Patterns
+
+### Test Data Builders
+
+Create reusable test data factories:
+
+```javascript
+class UserBuilder {
+  constructor() {
+    this.user = {
+      email: "test@example.com",
+      name: "Test User",
+      role: "user",
+    };
+  }
+
+  withEmail(email) {
+    this.user.email = email;
+    return this;
+  }
+
+  withRole(role) {
+    this.user.role = role;
+    return this;
+  }
+
+  build() {
+    return this.user;
+  }
+}
+
+// Usage
+const admin = new UserBuilder().withRole("admin").build();
+```
+
+### Mock Objects
+
+Replace external dependencies:
+
+```javascript
+const mockDatabase = {
+  findUser: jest.fn().mockResolvedValue({ id: 1, name: "John" }),
+  createUser: jest.fn().mockResolvedValue({ id: 2 }),
+};
+
+test("should fetch user from database", async () => {
+  const user = await getUserById(1, mockDatabase);
+  expect(mockDatabase.findUser).toHaveBeenCalledWith(1);
+  expect(user.name).toBe("John");
+});
+```
+
+### Spy Pattern
+
+Verify function calls without replacing behavior:
+
+```javascript
+const logger = {
+  log: jest.fn(),
+};
+
+performAction(logger);
+expect(logger.log).toHaveBeenCalledWith("Action performed");
+```
+
+## Integration Testing Patterns
+
+### Database Test Pattern
+
+```javascript
+beforeEach(async () => {
+  await database.reset();
+  await database.seed();
+});
+
+afterEach(async () => {
+  await database.cleanup();
+});
+
+test("should persist user to database", async () => {
+  const user = await createUser({ email: "test@example.com" });
+  const found = await database.users.findByEmail("test@example.com");
+  expect(found).toBeDefined();
+});
+```
+
+### API Test Pattern
+
+```javascript
+describe("POST /api/users", () => {
+  it("should create user and return 201", async () => {
+    const response = await request(app)
+      .post("/api/users")
+      .send({ email: "new@example.com", name: "New User" });
+
+    expect(response.status).toBe(201);
+    expect(response.body.email).toBe("new@example.com");
+  });
+});
+```
+
+## Behavior-Driven Development (BDD)
+
+Describe tests in business terms:
+
+```javascript
+describe("User Authentication", () => {
+  describe("when credentials are valid", () => {
+    it("grants access", async () => {
+      const result = await login("user@example.com", "password");
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe("when credentials are invalid", () => {
+    it("denies access", async () => {
+      const result = await login("user@example.com", "wrong");
+      expect(result.success).toBe(false);
+    });
+  });
+});
+```

package/.antigravity/skills/test-driven-development/references/testing-strategies.md

@@ -0,0 +1,131 @@
+# Testing Strategies
+
+## Frontend Component Testing
+
+### React Component Test
+
+```javascript
+import { render, screen, fireEvent } from "@testing-library/react";
+import LoginForm from "./LoginForm";
+
+test("should submit form with valid data", () => {
+  const onSubmit = jest.fn();
+  render(<LoginForm onSubmit={onSubmit} />);
+
+  fireEvent.change(screen.getByLabelText("Email"), {
+    target: { value: "test@example.com" },
+  });
+  fireEvent.change(screen.getByLabelText("Password"), {
+    target: { value: "password123" },
+  });
+  fireEvent.click(screen.getByText("Login"));
+
+  expect(onSubmit).toHaveBeenCalledWith({
+    email: "test@example.com",
+    password: "password123",
+  });
+});
+```
+
+### Vue Component Test
+
+```javascript
+import { mount } from "@vue/test-utils";
+import Counter from "./Counter.vue";
+
+test("increments counter on button click", async () => {
+  const wrapper = mount(Counter);
+  await wrapper.find("button").trigger("click");
+  expect(wrapper.text()).toContain("1");
+});
+```
+
+## API Endpoint Testing
+
+### REST API Test
+
+```javascript
+describe("GET /api/users/:id", () => {
+  it("returns user when exists", async () => {
+    const user = await createTestUser({ name: "John" });
+
+    const response = await request(app).get(`/api/users/${user.id}`);
+
+    expect(response.status).toBe(200);
+    expect(response.body.name).toBe("John");
+  });
+
+  it("returns 404 when user not found", async () => {
+    const response = await request(app).get("/api/users/999999");
+    expect(response.status).toBe(404);
+  });
+});
+```
+
+## Database Interaction Testing
+
+### Transaction Test Pattern
+
+```javascript
+test("should rollback on error", async () => {
+  await expect(async () => {
+    await database.transaction(async (trx) => {
+      await trx.users.create({ email: "test@example.com" });
+      throw new Error("Rollback!");
+    });
+  }).rejects.toThrow();
+
+  const user = await database.users.findByEmail("test@example.com");
+  expect(user).toBeNull();
+});
+```
+
+## Error Handling Tests
+
+```javascript
+test("should handle network errors gracefully", async () => {
+  mockApi.get.mockRejectedValue(new Error("Network error"));
+
+  const result = await fetchUserData(1);
+
+  expect(result.error).toBe("Failed to fetch data");
+  expect(result.data).toBeNull();
+});
+```
+
+## Edge Cases
+
+### Boundary Testing
+
+```javascript
+describe("Pagination", () => {
+  it("handles first page", async () => {
+    const result = await getUsers({ page: 1, limit: 10 });
+    expect(result.page).toBe(1);
+  });
+
+  it("handles last page", async () => {
+    const result = await getUsers({ page: 999, limit: 10 });
+    expect(result.data).toHaveLength(0);
+  });
+
+  it("handles negative page", async () => {
+    const result = await getUsers({ page: -1, limit: 10 });
+    expect(result.error).toBe("Invalid page number");
+  });
+});
+```
+
+### Null/Undefined Handling
+
+```javascript
+test("handles null input", () => {
+  expect(() => processUser(null)).toThrow("User cannot be null");
+});
+
+test("handles undefined properties", () => {
+  const user = { name: "John" }; // email is undefined
+  const result = validateUser(user);
+  expect(result.errors).toContain("Email is required");
+});
+```