antigravity-devkit 1.0.0

package/template/agents/test-engineer.md

@@ -0,0 +1,133 @@
+---
+name: test-engineer
+description: Testing expert. Writes unit, integration, and E2E tests. Triggers on test, xunit, vitest, coverage, tdd.
+tools: Read, Grep, Glob, Bash, Edit, Write
+model: inherit
+skills: clean-code, xunit-testing, vitest-testing, testing-patterns
+---
+
+# Test Engineer Agent
+
+You are a testing expert who ensures code quality through comprehensive tests.
+
+## Your Expertise
+
+- xUnit (C#/.NET)
+- Vitest (Vue3/TypeScript)
+- Test-driven development
+- Integration testing
+- E2E testing patterns
+
+---
+
+## Test Pyramid
+
+```
+        /\
+       /E2E\       Few, slow, critical paths
+      /------\
+     /Integr-\     Some, medium speed
+    /--ation--\
+   /   Unit    \   Many, fast, isolated
+  /--------------\
+```
+
+---
+
+## xUnit (C#)
+
+### Basic Test
+```csharp
+public class UserServiceTests
+{
+    [Fact]
+    public async Task GetById_ReturnsUser_WhenExists()
+    {
+        // Arrange
+        var service = CreateService();
+        
+        // Act
+        var result = await service.GetByIdAsync(1);
+        
+        // Assert
+        Assert.NotNull(result);
+        Assert.Equal(1, result.Id);
+    }
+}
+```
+
+### Theory with Data
+```csharp
+[Theory]
+[InlineData("", false)]
+[InlineData("valid@email.com", true)]
+public void ValidateEmail_ReturnsExpected(string email, bool expected)
+{
+    var result = EmailValidator.IsValid(email);
+    Assert.Equal(expected, result);
+}
+```
+
+---
+
+## Vitest (Vue3)
+
+### Component Test
+```typescript
+import { mount } from '@vue/test-utils'
+import { describe, it, expect } from 'vitest'
+import MyComponent from './MyComponent.vue'
+
+describe('MyComponent', () => {
+  it('emits click event', async () => {
+    const wrapper = mount(MyComponent)
+    await wrapper.find('button').trigger('click')
+    expect(wrapper.emitted('click')).toBeTruthy()
+  })
+})
+```
+
+---
+
+## AAA Pattern
+
+| Phase | Purpose |
+|-------|---------|
+| **Arrange** | Set up test data and mocks |
+| **Act** | Execute the code under test |
+| **Assert** | Verify the results |
+
+---
+
+## Mocking
+
+### C# with Moq
+```csharp
+var mockRepo = new Mock<IUserRepository>();
+mockRepo.Setup(r => r.GetByIdAsync(1))
+    .ReturnsAsync(new User { Id = 1 });
+```
+
+### TypeScript with vi
+```typescript
+vi.mock('./api', () => ({
+  fetchUser: vi.fn().mockResolvedValue({ id: 1 })
+}))
+```
+
+---
+
+## DO
+
+✅ Follow AAA pattern
+✅ One assertion per concept
+✅ Descriptive test names
+✅ Mock external dependencies
+✅ Test edge cases
+
+## DON'T
+
+❌ Test implementation details
+❌ Depend on test order
+❌ Share state between tests
+❌ Skip error cases

package/template/rules/GEMINI.md

@@ -0,0 +1,180 @@
+---
+trigger: always_on
+---
+
+# GEMINI.md - Vue3 + ASP.NET + Azure Kit
+
+> Global rules for AI behavior in this workspace.
+
+---
+
+## CRITICAL: AGENT & SKILL PROTOCOL
+
+> **MANDATORY:** Read agent file and skills BEFORE implementation.
+
+### Skill Loading Protocol
+```
+Agent activated → Check frontmatter "skills:" → Read SKILL.md → Apply rules
+```
+
+**Rule Priority:** P0 (GEMINI.md) > P1 (Agent .md) > P2 (SKILL.md)
+
+---
+
+## REQUEST CLASSIFIER
+
+| Request Type | Trigger Keywords | Agent | Result |
+|--------------|------------------|-------|--------|
+| QUESTION | "what is", "explain" | - | Text Response |
+| SURVEY | "analyze", "overview" | explorer-agent | Analysis |
+| VUE3 CODE | "component", "vue", "pinia" | frontend-specialist | Code |
+| ASPNET CODE | "controller", "api", "c#" | backend-specialist | Code |
+| DATABASE | "sql", "schema", "query" | database-architect | Code |
+| DEVOPS | "deploy", "pipeline", "aks" | devops-engineer | Config |
+| SECURITY | "audit", "keyvault", "owasp" | security-auditor | Report |
+| TEST | "test", "xunit", "vitest" | test-engineer | Tests |
+| DEBUG | "fix", "error", "bug" | debugger | Fix |
+| SLASH CMD | /create, /plan, /deploy | Command-specific | Variable |
+
+---
+
+## INTELLIGENT AGENT ROUTING
+
+**ALWAYS ACTIVE:** Auto-select best agent before responding.
+
+### Protocol
+1. **Analyze**: Detect domain (Frontend, Backend, Database, DevOps)
+2. **Select**: Choose specialist agent
+3. **Inform**: State which agent is applied
+4. **Apply**: Use agent's rules and skills
+
+### Response Format
+```markdown
+🤖 **Applying `@[agent-name]`...**
+[Specialized response]
+```
+
+---
+
+## TIER 0: UNIVERSAL RULES
+
+### Language Handling
+- Respond in user's language
+- Code comments/variables in English
+
+### Clean Code (Global)
+**ALL code MUST follow `@[skills/clean-code]`. No exceptions.**
+
+| Principle | Rule |
+|-----------|------|
+| SRP | Single responsibility |
+| DRY | No duplication |
+| KISS | Simplest solution |
+| YAGNI | No unused features |
+
+### File Dependency Awareness
+Before modifying ANY file:
+1. Identify dependent files
+2. Update ALL affected files together
+
+### Read → Understand → Apply
+```
+❌ WRONG: Read agent → Start coding
+✅ CORRECT: Read → Understand WHY → Apply PRINCIPLES → Code
+```
+
+---
+
+## TIER 1: CODE RULES
+
+### Project Type Routing
+
+| Project Type | Agent | Skills |
+|--------------|-------|--------|
+| VUE3 | frontend-specialist | vue3-patterns, vitest-testing |
+| ASPNET | backend-specialist | aspnet-patterns, csharp-patterns |
+| DATABASE | database-architect | sqlserver-design |
+| DEVOPS | devops-engineer | azure-devops, azure-aks |
+
+### Socratic Gate
+
+**For complex requests, ASK first:**
+
+| Request Type | Action |
+|--------------|--------|
+| New Feature | Ask 3+ strategic questions |
+| Bug Fix | Confirm understanding |
+| Vague Request | Clarify Purpose, Users, Scope |
+
+**Protocol:**
+1. Never Assume - if unclear, ASK
+2. Wait for confirmation before coding
+
+### Human-in-the-Loop Checkpoints
+
+| Stage | Action |
+|-------|--------|
+| /plan | Approve before coding |
+| /review | Approve before deploy |
+| /deploy | Approve before trigger |
+
+---
+
+## TIER 2: STACK-SPECIFIC RULES
+
+### Vue3 Frontend
+- Composition API only (no Options API)
+- Pinia for state management
+- TypeScript strict mode
+- Vitest for testing
+
+### ASP.NET Backend
+- Controller → Service → Repository pattern
+- Async/await everywhere
+- Dependency injection
+- xUnit for testing
+
+### SQL Server Database
+- Proper indexing
+- Stored procedures for complex logic
+- Migration scripts
+
+### Azure DevOps
+- YAML pipelines
+- GitOps patterns
+- KeyVault for secrets
+
+---
+
+## VERIFICATION SCRIPTS
+
+### Agent → Script Mapping
+
+| Agent | Script |
+|-------|--------|
+| frontend-specialist | vitest_runner.py |
+| backend-specialist | xunit_runner.py |
+| database-architect | schema_validator.py |
+| security-auditor | security_scan.py |
+| Any agent | lint_runner.py |
+
+### Script Output Protocol
+1. Run script
+2. Parse errors/warnings
+3. Summarize to user
+4. Ask before fixing
+
+---
+
+## QUICK REFERENCE
+
+### Agents
+- **Masters**: orchestrator, project-planner
+- **Code**: frontend-specialist, backend-specialist, database-architect
+- **Ops**: devops-engineer, security-auditor, test-engineer
+- **Support**: debugger, performance-optimizer, documentation-writer
+
+### Key Skills
+- **Core**: clean-code, architecture, brainstorming, plan-writing
+- **Stack**: vue3-patterns, aspnet-patterns, sqlserver-design
+- **Azure**: azure-devops, azure-aks, azure-keyvault

package/template/scripts/checklist.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+"""
+Checklist - Priority-based project validation
+Run during development and pre-commit.
+
+Usage:
+    python .agent-antigravity/scripts/checklist.py .
+    python .agent-antigravity/scripts/checklist.py . --url http://localhost:3000
+"""
+
+import subprocess
+import sys
+import os
+from pathlib import Path
+
+
+def run_command(cmd: list[str], cwd: str = ".") -> tuple[int, str]:
+    """Run a command and return exit code and output."""
+    try:
+        result = subprocess.run(
+            cmd,
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=300
+        )
+        return result.returncode, result.stdout + result.stderr
+    except subprocess.TimeoutExpired:
+        return 1, "Command timed out"
+    except FileNotFoundError:
+        return 1, f"Command not found: {cmd[0]}"
+
+
+def check_frontend_lint(project_path: str) -> tuple[bool, str]:
+    """Check frontend linting."""
+    package_json = Path(project_path) / "package.json"
+    if not package_json.exists():
+        return True, "No package.json found, skipping frontend lint"
+    
+    code, output = run_command(["npm", "run", "lint"], project_path)
+    return code == 0, output
+
+
+def check_frontend_types(project_path: str) -> tuple[bool, str]:
+    """Check TypeScript types."""
+    package_json = Path(project_path) / "package.json"
+    if not package_json.exists():
+        return True, "No package.json found, skipping type check"
+    
+    code, output = run_command(["npm", "run", "type-check"], project_path)
+    if code != 0:
+        # Try alternative command
+        code, output = run_command(["npx", "tsc", "--noEmit"], project_path)
+    return code == 0, output
+
+
+def check_backend_build(project_path: str) -> tuple[bool, str]:
+    """Check .NET build."""
+    sln_files = list(Path(project_path).glob("*.sln"))
+    csproj_files = list(Path(project_path).glob("**/*.csproj"))
+    
+    if not sln_files and not csproj_files:
+        return True, "No .NET project found, skipping build"
+    
+    code, output = run_command(["dotnet", "build"], project_path)
+    return code == 0, output
+
+
+def check_backend_tests(project_path: str) -> tuple[bool, str]:
+    """Check .NET tests."""
+    sln_files = list(Path(project_path).glob("*.sln"))
+    if not sln_files:
+        return True, "No .NET solution found, skipping tests"
+    
+    code, output = run_command(["dotnet", "test"], project_path)
+    return code == 0, output
+
+
+def check_frontend_tests(project_path: str) -> tuple[bool, str]:
+    """Check frontend tests."""
+    package_json = Path(project_path) / "package.json"
+    if not package_json.exists():
+        return True, "No package.json found, skipping tests"
+    
+    code, output = run_command(["npm", "run", "test", "--", "--run"], project_path)
+    return code == 0, output
+
+
+def check_security(project_path: str) -> tuple[bool, str]:
+    """Check for security issues."""
+    issues = []
+    
+    # Check for hardcoded secrets patterns
+    secret_patterns = ["password=", "apikey=", "secret=", "connectionstring="]
+    for pattern in secret_patterns:
+        code, output = run_command(
+            ["grep", "-ri", pattern, "--include=*.cs", "--include=*.ts", "--include=*.json"],
+            project_path
+        )
+        if code == 0 and output.strip():
+            issues.append(f"Potential secret found: {pattern}")
+    
+    # Check npm audit
+    package_json = Path(project_path) / "package.json"
+    if package_json.exists():
+        code, output = run_command(["npm", "audit", "--audit-level=high"], project_path)
+        if code != 0:
+            issues.append("npm audit found high severity vulnerabilities")
+    
+    if issues:
+        return False, "\n".join(issues)
+    return True, "No security issues found"
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python checklist.py <project_path> [--url <url>]")
+        sys.exit(1)
+    
+    project_path = sys.argv[1]
+    url = None
+    if "--url" in sys.argv:
+        url_index = sys.argv.index("--url") + 1
+        if url_index < len(sys.argv):
+            url = sys.argv[url_index]
+    
+    print("=" * 60)
+    print("PROJECT CHECKLIST")
+    print("=" * 60)
+    
+    checks = [
+        ("Security", check_security),
+        ("Frontend Lint", check_frontend_lint),
+        ("Frontend Types", check_frontend_types),
+        ("Frontend Tests", check_frontend_tests),
+        ("Backend Build", check_backend_build),
+        ("Backend Tests", check_backend_tests),
+    ]
+    
+    results = []
+    for name, check_fn in checks:
+        print(f"\n[{name}]")
+        passed, output = check_fn(project_path)
+        status = "✅ PASS" if passed else "❌ FAIL"
+        print(f"  {status}")
+        if not passed:
+            print(f"  {output[:500]}")
+        results.append((name, passed))
+    
+    print("\n" + "=" * 60)
+    print("SUMMARY")
+    print("=" * 60)
+    
+    passed_count = sum(1 for _, p in results if p)
+    total_count = len(results)
+    
+    for name, passed in results:
+        status = "✅" if passed else "❌"
+        print(f"  {status} {name}")
+    
+    print(f"\nResult: {passed_count}/{total_count} checks passed")
+    
+    if passed_count < total_count:
+        sys.exit(1)
+    
+    print("\n✅ All checks passed!")
+
+
+if __name__ == "__main__":
+    main()