antigravity-init 1.0.0

package/.agent/workflows/build-fix.md

@@ -0,0 +1,212 @@
+---
+description: Incrementally fix TypeScript and build errors one at a time
+---
+
+# Build and Fix Workflow
+
+Systematically fix TypeScript and build errors incrementally.
+
+## When to Use
+
+- Build is failing
+- TypeScript errors present
+- After major refactoring
+- After dependency updates
+- When errors are overwhelming
+
+## Strategy
+
+**Fix one error at a time for safety!**
+
+Avoid cascading failures by:
+- Fixing errors incrementally
+- Verifying each fix before moving to next
+- Stopping if fix introduces new errors
+
+## Steps
+
+### 1. Run Build
+```bash
+npm run build
+# or
+pnpm build
+# or
+yarn build
+```
+
+### 2. Parse Error Output
+
+Group errors by:
+- File location
+- Error type
+- Severity
+
+Sort by:
+- CRITICAL (blocking) first
+- HIGH (important) second
+- MEDIUM/LOW last
+
+### 3. Fix Each Error Incrementally
+
+For each error:
+
+#### a) Show Error Context
+```bash
+# View 5 lines before/after error location
+```
+
+#### b) Explain the Issue
+Understand what's causing the error:
+- Type mismatch?
+- Missing import?
+- Syntax error?
+- Configuration issue?
+
+#### c) Propose Fix
+Suggest the appropriate fix:
+```typescript
+// ❌ Current (broken)
+const value: string = 123
+
+// ✅ Fixed
+const value: string = "123"
+```
+
+#### d) Apply Fix
+Make the change to the file
+
+#### e) Re-run Build
+```bash
+npm run build
+```
+
+#### f) Verify Error Resolved
+- ✅ Error is gone
+- ✅ No new errors introduced
+- ✅ Build progresses further
+
+### 4. Stop Conditions
+
+Stop fixing if:
+- ❌ Fix introduces new errors
+- ❌ Same error persists after 3 attempts
+- ❌ User requests pause
+- ❌ Errors seem to be cascading
+- ❌ Root cause is unclear
+
+**Ask for help** if stuck!
+
+### 5. Show Summary
+
+After fixing session:
+
+```
+╔══════════════════════════════════════╗
+║         Build Fix Summary            ║
+╠══════════════════════════════════════╣
+║ Errors Fixed:      X                 ║
+║ Errors Remaining:  Y                 ║
+║ New Errors:        Z                 ║
+║ Status:            [PASS/FAIL]       ║
+╚══════════════════════════════════════╝
+```
+
+## Common Error Types
+
+### TypeScript Errors
+
+**Type Mismatch:**
+```typescript
+// ❌ Error: Type 'number' is not assignable to type 'string'
+const name: string = 123
+
+// ✅ Fix
+const name: string = "123"
+```
+
+**Missing Property:**
+```typescript
+// ❌ Error: Property 'id' is missing
+const user: User = { name: "John" }
+
+// ✅ Fix
+const user: User = { id: 1, name: "John" }
+```
+
+**Null/Undefined:**
+```typescript
+// ❌ Error: Object is possibly 'undefined'
+const value = data.value
+
+// ✅ Fix
+const value = data?.value ?? defaultValue
+```
+
+### Build Errors
+
+**Missing Dependency:**
+```bash
+# ❌ Error: Cannot find module 'lodash'
+npm install lodash
+npm install --save-dev @types/lodash
+```
+
+**Configuration Issue:**
+```json
+// tsconfig.json
+{
+  "compilerOptions": {
+    "strict": true,
+    "skipLibCheck": true // Add if type errors in node_modules
+  }
+}
+```
+
+## Best Practices
+
+**DO:**
+- ✅ Fix one error at a time
+- ✅ Verify each fix before moving on
+- ✅ Understand the root cause
+- ✅ Run build after each fix
+- ✅ Commit working fixes incrementally
+
+**DON'T:**
+- ❌ Try to fix all errors at once
+- ❌ Skip verification steps
+- ❌ Use `@ts-ignore` without understanding
+- ❌ Disable strict mode to hide errors
+- ❌ Continue if errors are cascading
+
+## Safety Checks
+
+Before applying a fix:
+- [ ] Understand why the error occurred
+- [ ] Know what the fix will change
+- [ ] Have a plan if fix fails
+- [ ] Can revert if needed
+
+After applying a fix:
+- [ ] Build runs further than before
+- [ ] No new errors introduced
+- [ ] Error is actually resolved
+- [ ] Code still makes sense
+
+## Important Notes
+
+**CRITICAL:** 
+- One error at a time
+- Verify after each fix
+- Stop if cascading failures
+- Ask for help if stuck
+
+**Never:**
+- Blindly apply fixes
+- Use `any` type everywhere
+- Disable TypeScript checks
+- Skip understanding the error
+
+## Related
+
+- Agent: `build-error-resolver` in `.agent/agents/build-error-resolver.md`
+- Skill: `systematic-debugging` in `.agent/skills/systematic-debugging/`

package/.agent/workflows/code-review.md

@@ -0,0 +1,169 @@
+---
+description: Comprehensive security and quality review of code changes
+---
+
+# Code Review Workflow
+
+Perform comprehensive security and quality review of uncommitted changes.
+
+## When to Use
+
+- Before committing code
+- Before creating pull requests
+- After implementing features
+- When security is critical
+- Before production deployment
+
+## Steps
+
+### 1. Get Changed Files
+```bash
+git diff --name-only HEAD
+```
+
+### 2. Review Each File for Issues
+
+#### Security Issues (CRITICAL) 🔴
+
+Check for:
+- [ ] Hardcoded credentials, API keys, tokens
+- [ ] SQL injection vulnerabilities
+- [ ] XSS vulnerabilities  
+- [ ] Missing input validation
+- [ ] Insecure dependencies
+- [ ] Path traversal risks
+- [ ] Command injection
+- [ ] Insufficient authorization
+- [ ] Race conditions in financial operations
+- [ ] Logging sensitive data
+
+#### Code Quality (HIGH) 🟡
+
+Check for:
+- [ ] Functions > 50 lines
+- [ ] Files > 800 lines
+- [ ] Nesting depth > 4 levels
+- [ ] Missing error handling
+- [ ] console.log statements
+- [ ] TODO/FIXME comments
+- [ ] Missing JSDoc for public APIs
+- [ ] Duplicate code
+- [ ] Complex conditionals
+
+#### Best Practices (MEDIUM) 🟢
+
+Check for:
+- [ ] Mutation patterns (use immutable instead)
+- [ ] Emoji usage in code/comments
+- [ ] Missing tests for new code
+- [ ] Accessibility issues (a11y)
+- [ ] Performance concerns
+- [ ] Inconsistent naming
+- [ ] Missing type annotations
+
+### 3. Generate Report
+
+For each issue found, document:
+
+**Severity:** CRITICAL | HIGH | MEDIUM | LOW
+
+**Location:** `file.ts:line`
+
+**Issue:** Description of the problem
+
+**Suggested Fix:**
+```typescript
+// ✅ Correct implementation
+```
+
+### 4. Decision
+
+- **BLOCK** if CRITICAL or HIGH security issues found
+- **REQUEST CHANGES** if HIGH quality issues found
+- **APPROVE WITH SUGGESTIONS** if only MEDIUM/LOW issues
+- **APPROVE** if no issues found
+
+## Security Checklist
+
+Before approving any code:
+
+- [ ] No hardcoded secrets
+- [ ] All inputs validated
+- [ ] SQL injection prevention (parameterized queries)
+- [ ] XSS prevention (sanitized HTML)
+- [ ] CSRF protection enabled
+- [ ] Authentication/authorization verified
+- [ ] Rate limiting on endpoints
+- [ ] Error messages don't leak sensitive data
+- [ ] Dependencies up to date
+- [ ] No vulnerable packages
+
+## Quality Checklist
+
+- [ ] Code follows project style guide
+- [ ] Functions are small and focused
+- [ ] Files are reasonably sized
+- [ ] Error handling is comprehensive
+- [ ] Tests cover new code (80%+ coverage)
+- [ ] Documentation is updated
+- [ ] No debug code (console.log, debugger)
+- [ ] Performance is acceptable
+
+## Report Template
+
+```markdown
+# Code Review Report
+
+**Reviewer:** [Your Name]
+**Date:** [Date]
+**Files Reviewed:** [Count]
+
+## Summary
+
+- **Critical Issues:** X
+- **High Issues:** Y
+- **Medium Issues:** Z
+- **Low Issues:** W
+- **Risk Level:** 🔴 HIGH / 🟡 MEDIUM / 🟢 LOW
+
+## Critical Issues (Fix Immediately)
+
+### 1. [Issue Title]
+**File:** `path/to/file.ts:123`
+**Severity:** CRITICAL
+**Category:** SQL Injection
+
+**Issue:**
+[Description]
+
+**Fix:**
+```typescript
+// ✅ Correct implementation
+```
+
+## Decision
+
+**BLOCK** / **REQUEST CHANGES** / **APPROVE WITH SUGGESTIONS** / **APPROVE**
+
+---
+
+Never approve code with security vulnerabilities!
+```
+
+## Important Notes
+
+**CRITICAL:** Never approve code with:
+- Hardcoded secrets
+- SQL injection vulnerabilities
+- Missing authentication/authorization
+- Unvalidated user input
+- Known security vulnerabilities
+
+**Block the commit/PR** until these are fixed.
+
+## Related
+
+- Agent: `code-reviewer` in `.agent/agents/code-reviewer.md`
+- Agent: `security-reviewer` in `.agent/agents/security-reviewer.md`
+- Skill: `security-review` in `.agent/skills/security-review/`
+- Rules: `.agent/rules/security.md`

package/.agent/workflows/execute-plan.md

@@ -0,0 +1,5 @@
+---
+description: Execute plan in batches
+---
+
+Invoke the executing-plans skill and follow it exactly as presented to you.

package/.agent/workflows/tdd-workflow.md

@@ -0,0 +1,166 @@
+---
+description: Test-Driven Development workflow - write tests first, implement minimal code, refactor
+---
+
+# TDD Workflow
+
+Enforce test-driven development methodology with RED → GREEN → REFACTOR cycle.
+
+## When to Use
+
+- Implementing new features
+- Adding new functions/components
+- Fixing bugs (write test that reproduces bug first)
+- Refactoring existing code
+- Building critical business logic
+
+## TDD Cycle
+
+```
+RED → GREEN → REFACTOR → REPEAT
+
+RED:      Write a failing test
+GREEN:    Write minimal code to pass
+REFACTOR: Improve code, keep tests passing
+REPEAT:   Next feature/scenario
+```
+
+## Steps
+
+### 1. Define Interface (SCAFFOLD)
+Define types/interfaces first before any implementation.
+
+```typescript
+export interface MyData {
+  // Define your data structure
+}
+
+export function myFunction(data: MyData): ReturnType {
+  throw new Error('Not implemented')
+}
+```
+
+### 2. Write Failing Test (RED)
+Write tests that will FAIL because code doesn't exist yet.
+
+```typescript
+import { myFunction } from './myModule'
+
+describe('myFunction', () => {
+  it('should handle happy path', () => {
+    const result = myFunction(testData)
+    expect(result).toBe(expectedValue)
+  })
+
+  it('should handle edge cases', () => {
+    // Test edge cases
+  })
+
+  it('should handle errors', () => {
+    // Test error conditions
+  })
+})
+```
+
+### 3. Run Tests - Verify FAIL
+```bash
+npm test
+# Verify tests fail for the RIGHT reason
+```
+
+✅ Tests should fail with "Not implemented" or similar
+
+### 4. Implement Minimal Code (GREEN)
+Write just enough code to make tests pass.
+
+```typescript
+export function myFunction(data: MyData): ReturnType {
+  // Minimal implementation to pass tests
+  return result
+}
+```
+
+### 5. Run Tests - Verify PASS
+```bash
+npm test
+# All tests should pass
+```
+
+✅ All tests passing!
+
+### 6. Refactor (IMPROVE)
+Improve code quality while keeping tests green.
+
+- Extract constants
+- Improve readability
+- Add helper functions
+- Optimize performance
+
+### 7. Verify Tests Still Pass
+```bash
+npm test
+# Tests should still pass after refactoring
+```
+
+### 8. Check Coverage
+```bash
+npm test -- --coverage
+# Ensure 80%+ coverage (100% for critical code)
+```
+
+## Coverage Requirements
+
+- **80% minimum** for all code
+- **100% required** for:
+  - Financial calculations
+  - Authentication logic
+  - Security-critical code
+  - Core business logic
+
+## Best Practices
+
+**DO:**
+- ✅ Write the test FIRST, before any implementation
+- ✅ Run tests and verify they FAIL before implementing
+- ✅ Write minimal code to make tests pass
+- ✅ Refactor only after tests are green
+- ✅ Add edge cases and error scenarios
+- ✅ Aim for 80%+ coverage
+
+**DON'T:**
+- ❌ Write implementation before tests
+- ❌ Skip running tests after each change
+- ❌ Write too much code at once
+- ❌ Ignore failing tests
+- ❌ Test implementation details (test behavior)
+- ❌ Mock everything (prefer integration tests)
+
+## Test Types
+
+**Unit Tests** (Function-level):
+- Happy path scenarios
+- Edge cases (empty, null, max values)
+- Error conditions
+- Boundary values
+
+**Integration Tests** (Component-level):
+- API endpoints
+- Database operations
+- External service calls
+- React components with hooks
+
+**E2E Tests** (use `/e2e` workflow):
+- Critical user flows
+- Multi-step processes
+- Full stack integration
+
+## Important Notes
+
+**MANDATORY**: Tests must be written BEFORE implementation.
+
+Never skip the RED phase. Never write code before tests.
+
+## Related
+
+- Agent: `tdd-guide` in `.agent/agents/tdd-guide.md`
+- Skill: `test-driven-development` in `.agent/skills/test-driven-development/`