antigravity-devkit 1.0.0

package/template/scripts/verify_all.py

@@ -0,0 +1,243 @@
+#!/usr/bin/env python3
+"""
+Verify All - Comprehensive project verification
+Run before deployment or releases.
+
+Usage:
+    python .agent-antigravity/scripts/verify_all.py .
+    python .agent-antigravity/scripts/verify_all.py . --url http://localhost:3000
+"""
+
+import subprocess
+import sys
+import os
+from pathlib import Path
+from datetime import datetime
+
+
+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=600
+        )
+        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]}"
+
+
+class Verifier:
+    def __init__(self, project_path: str, url: str = None):
+        self.project_path = project_path
+        self.url = url
+        self.results = []
+    
+    def add_result(self, category: str, name: str, passed: bool, details: str = ""):
+        self.results.append({
+            "category": category,
+            "name": name,
+            "passed": passed,
+            "details": details
+        })
+    
+    def run_all(self):
+        """Run all verification checks."""
+        print("=" * 70)
+        print("COMPREHENSIVE PROJECT VERIFICATION")
+        print(f"Started: {datetime.now().isoformat()}")
+        print("=" * 70)
+        
+        self.verify_security()
+        self.verify_code_quality()
+        self.verify_tests()
+        self.verify_build()
+        self.verify_dependencies()
+        
+        if self.url:
+            self.verify_runtime(self.url)
+        
+        self.print_summary()
+    
+    def verify_security(self):
+        """Security verification."""
+        print("\n[SECURITY]")
+        
+        # Check for secrets
+        secret_patterns = [
+            ("password", "password="),
+            ("api_key", "apikey="),
+            ("secret", "secret="),
+            ("connection_string", "connectionstring="),
+        ]
+        
+        for name, pattern in secret_patterns:
+            code, output = run_command(
+                ["grep", "-ri", pattern, "--include=*.cs", "--include=*.ts"],
+                self.project_path
+            )
+            passed = code != 0 or not output.strip()
+            self.add_result("Security", f"No hardcoded {name}", passed)
+            print(f"  {'✅' if passed else '❌'} No hardcoded {name}")
+        
+        # npm audit
+        package_json = Path(self.project_path) / "package.json"
+        if package_json.exists():
+            code, output = run_command(["npm", "audit", "--audit-level=critical"], self.project_path)
+            passed = code == 0
+            self.add_result("Security", "npm audit (critical)", passed, output[:200])
+            print(f"  {'✅' if passed else '❌'} npm audit (critical)")
+    
+    def verify_code_quality(self):
+        """Code quality verification."""
+        print("\n[CODE QUALITY]")
+        
+        # Frontend lint
+        package_json = Path(self.project_path) / "package.json"
+        if package_json.exists():
+            code, output = run_command(["npm", "run", "lint"], self.project_path)
+            passed = code == 0
+            self.add_result("Code Quality", "Frontend lint", passed)
+            print(f"  {'✅' if passed else '❌'} Frontend lint")
+            
+            # TypeScript
+            code, output = run_command(["npx", "tsc", "--noEmit"], self.project_path)
+            passed = code == 0
+            self.add_result("Code Quality", "TypeScript check", passed)
+            print(f"  {'✅' if passed else '❌'} TypeScript check")
+        
+        # Backend lint (if applicable)
+        csproj_files = list(Path(self.project_path).glob("**/*.csproj"))
+        if csproj_files:
+            code, output = run_command(["dotnet", "format", "--verify-no-changes"], self.project_path)
+            passed = code == 0
+            self.add_result("Code Quality", "C# formatting", passed)
+            print(f"  {'✅' if passed else '❌'} C# formatting")
+    
+    def verify_tests(self):
+        """Test verification."""
+        print("\n[TESTS]")
+        
+        # Frontend tests
+        package_json = Path(self.project_path) / "package.json"
+        if package_json.exists():
+            code, output = run_command(["npm", "run", "test", "--", "--run"], self.project_path)
+            passed = code == 0
+            self.add_result("Tests", "Frontend tests", passed)
+            print(f"  {'✅' if passed else '❌'} Frontend tests")
+        
+        # Backend tests
+        sln_files = list(Path(self.project_path).glob("*.sln"))
+        if sln_files:
+            code, output = run_command(["dotnet", "test"], self.project_path)
+            passed = code == 0
+            self.add_result("Tests", "Backend tests", passed)
+            print(f"  {'✅' if passed else '❌'} Backend tests")
+    
+    def verify_build(self):
+        """Build verification."""
+        print("\n[BUILD]")
+        
+        # Frontend build
+        package_json = Path(self.project_path) / "package.json"
+        if package_json.exists():
+            code, output = run_command(["npm", "run", "build"], self.project_path)
+            passed = code == 0
+            self.add_result("Build", "Frontend build", passed)
+            print(f"  {'✅' if passed else '❌'} Frontend build")
+        
+        # Backend build
+        sln_files = list(Path(self.project_path).glob("*.sln"))
+        if sln_files:
+            code, output = run_command(["dotnet", "build", "-c", "Release"], self.project_path)
+            passed = code == 0
+            self.add_result("Build", "Backend build", passed)
+            print(f"  {'✅' if passed else '❌'} Backend build")
+    
+    def verify_dependencies(self):
+        """Dependency verification."""
+        print("\n[DEPENDENCIES]")
+        
+        # npm outdated
+        package_json = Path(self.project_path) / "package.json"
+        if package_json.exists():
+            code, output = run_command(["npm", "outdated"], self.project_path)
+            # outdated returns 1 if there are outdated packages
+            self.add_result("Dependencies", "npm packages", True, "Check npm outdated for details")
+            print(f"  ℹ️  npm outdated check complete")
+        
+        # dotnet outdated (if tool installed)
+        sln_files = list(Path(self.project_path).glob("*.sln"))
+        if sln_files:
+            code, output = run_command(["dotnet", "list", "package", "--outdated"], self.project_path)
+            self.add_result("Dependencies", "NuGet packages", True, "Check dotnet list package for details")
+            print(f"  ℹ️  NuGet outdated check complete")
+    
+    def verify_runtime(self, url: str):
+        """Runtime verification (if URL provided)."""
+        print("\n[RUNTIME]")
+        
+        # Health check
+        code, output = run_command(["curl", "-s", "-o", "/dev/null", "-w", "%{http_code}", f"{url}/health"])
+        passed = output.strip() == "200"
+        self.add_result("Runtime", "Health check", passed)
+        print(f"  {'✅' if passed else '❌'} Health check")
+    
+    def print_summary(self):
+        """Print verification summary."""
+        print("\n" + "=" * 70)
+        print("VERIFICATION SUMMARY")
+        print("=" * 70)
+        
+        categories = {}
+        for r in self.results:
+            cat = r["category"]
+            if cat not in categories:
+                categories[cat] = []
+            categories[cat].append(r)
+        
+        total_passed = 0
+        total_count = 0
+        
+        for cat, items in categories.items():
+            print(f"\n{cat}:")
+            for item in items:
+                status = "✅" if item["passed"] else "❌"
+                print(f"  {status} {item['name']}")
+                total_count += 1
+                if item["passed"]:
+                    total_passed += 1
+        
+        print("\n" + "-" * 70)
+        print(f"Total: {total_passed}/{total_count} checks passed")
+        
+        if total_passed < total_count:
+            print("\n❌ Some checks failed. Review and fix before deployment.")
+            sys.exit(1)
+        else:
+            print("\n✅ All checks passed! Ready for deployment.")
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python verify_all.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]
+    
+    verifier = Verifier(project_path, url)
+    verifier.run_all()
+
+
+if __name__ == "__main__":
+    main()

package/template/skills/api-patterns/SKILL.md

@@ -0,0 +1,116 @@
+---
+name: api-patterns
+description: REST API design patterns and best practices
+---
+
+# API Patterns
+
+> RESTful API design for ASP.NET Core.
+
+---
+
+## REST Conventions
+
+| Method | Action | Route | Response |
+|--------|--------|-------|----------|
+| GET | List | /api/users | 200 + array |
+| GET | Read | /api/users/{id} | 200 or 404 |
+| POST | Create | /api/users | 201 + object |
+| PUT | Update | /api/users/{id} | 200 or 404 |
+| DELETE | Delete | /api/users/{id} | 204 or 404 |
+
+---
+
+## Response Format
+
+```csharp
+public class ApiResponse<T>
+{
+    public bool Success { get; set; }
+    public T? Data { get; set; }
+    public string? Error { get; set; }
+    public List<string>? Errors { get; set; }
+}
+```
+
+---
+
+## Pagination
+
+```csharp
+[HttpGet]
+public async Task<ActionResult<PagedResult<UserDto>>> GetUsers(
+    [FromQuery] int page = 1,
+    [FromQuery] int pageSize = 20)
+{
+    var result = await _service.GetPagedAsync(page, pageSize);
+    return Ok(result);
+}
+
+public class PagedResult<T>
+{
+    public List<T> Items { get; set; }
+    public int TotalCount { get; set; }
+    public int Page { get; set; }
+    public int PageSize { get; set; }
+}
+```
+
+---
+
+## Validation
+
+```csharp
+public class CreateUserDto
+{
+    [Required]
+    [EmailAddress]
+    public string Email { get; set; }
+    
+    [Required]
+    [StringLength(100, MinimumLength = 2)]
+    public string Name { get; set; }
+}
+```
+
+---
+
+## Error Handling
+
+```csharp
+// Global exception handler
+app.UseExceptionHandler(app =>
+{
+    app.Run(async context =>
+    {
+        context.Response.StatusCode = 500;
+        await context.Response.WriteAsJsonAsync(new ApiResponse<object>
+        {
+            Success = false,
+            Error = "An error occurred"
+        });
+    });
+});
+```
+
+---
+
+## Versioning
+
+```csharp
+[ApiController]
+[Route("api/v{version:apiVersion}/[controller]")]
+[ApiVersion("1.0")]
+public class UsersController : ControllerBase
+```
+
+---
+
+## DO / DON'T
+
+| ✅ Do | ❌ Don't |
+|-------|---------|
+| Consistent responses | Mixed formats |
+| Proper status codes | 200 for everything |
+| Validate input | Trust user data |
+| Version APIs | Breaking changes |

package/template/skills/architecture/SKILL.md

@@ -0,0 +1,98 @@
+---
+name: architecture
+description: System design patterns and architecture decisions
+---
+
+# Architecture Patterns
+
+> System design for Vue3 + ASP.NET applications.
+
+---
+
+## Layered Architecture
+
+```
+┌─────────────────────────────────────┐
+│         Presentation (Vue3)         │
+├─────────────────────────────────────┤
+│          API (Controllers)          │
+├─────────────────────────────────────┤
+│        Business Logic (Services)    │
+├─────────────────────────────────────┤
+│         Data Access (Repositories)  │
+├─────────────────────────────────────┤
+│          Database (SQL Server)      │
+└─────────────────────────────────────┘
+```
+
+---
+
+## Frontend Architecture
+
+```
+src/
+├── components/     # Reusable UI components
+├── composables/    # Shared logic (useXxx)
+├── views/          # Page components
+├── stores/         # Pinia stores
+├── api/            # API client
+├── types/          # TypeScript types
+└── router/         # Vue Router
+```
+
+---
+
+## Backend Architecture
+
+```
+src/
+├── Controllers/    # HTTP endpoints
+├── Services/       # Business logic
+├── Repositories/   # Data access
+├── Models/         # Domain models
+├── DTOs/           # Data transfer objects
+└── Infrastructure/ # Cross-cutting concerns
+```
+
+---
+
+## Communication Patterns
+
+| Pattern | Use Case |
+|---------|----------|
+| REST API | Standard CRUD operations |
+| SignalR | Real-time updates |
+| Background Jobs | Async processing |
+| Message Queue | Event-driven systems |
+
+---
+
+## Decision Matrix
+
+| Decision | Option A | Option B |
+|----------|----------|----------|
+| State management | Pinia | Composables |
+| API calls | Axios | Fetch |
+| Forms | VeeValidate | Native |
+| Testing | Vitest | Jest |
+
+---
+
+## Scaling Considerations
+
+| Layer | Strategy |
+|-------|----------|
+| Frontend | CDN, code splitting |
+| API | Horizontal scaling, load balancer |
+| Database | Read replicas, caching |
+| Background | Worker processes |
+
+---
+
+## DO / DON'T
+
+| ✅ Do | ❌ Don't |
+|-------|---------|
+| Clear layer separation | Mixed concerns |
+| Dependency injection | Hard dependencies |
+| Interface-based design | Concrete dependencies |

package/template/skills/aspnet-patterns/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: aspnet-patterns
+description: ASP.NET Core patterns - Controllers, Services, Middleware
+---
+
+# ASP.NET Core Patterns
+
+> Clean architecture for ASP.NET Core applications.
+
+---
+
+## Architecture
+
+```
+Controller → Service → Repository → Database
+```
+
+| Layer | Responsibility |
+|-------|----------------|
+| Controller | HTTP handling, validation |
+| Service | Business logic |
+| Repository | Data access |
+
+---
+
+## Controller Pattern
+
+```csharp
+[ApiController]
+[Route("api/[controller]")]
+public class UsersController : ControllerBase
+{
+    private readonly IUserService _userService;
+
+    public UsersController(IUserService userService)
+    {
+        _userService = userService;
+    }
+
+    [HttpGet("{id}")]
+    public async Task<ActionResult<UserDto>> GetById(int id)
+    {
+        var user = await _userService.GetByIdAsync(id);
+        return user is null ? NotFound() : Ok(user);
+    }
+
+    [HttpPost]
+    public async Task<ActionResult<UserDto>> Create(CreateUserDto dto)
+    {
+        var user = await _userService.CreateAsync(dto);
+        return CreatedAtAction(nameof(GetById), new { id = user.Id }, user);
+    }
+}
+```
+
+---
+
+## Service Pattern
+
+```csharp
+public class UserService : IUserService
+{
+    private readonly IUserRepository _repository;
+
+    public UserService(IUserRepository repository)
+    {
+        _repository = repository;
+    }
+
+    public async Task<UserDto?> GetByIdAsync(int id)
+    {
+        var user = await _repository.GetByIdAsync(id);
+        return user?.ToDto();
+    }
+}
+```
+
+---
+
+## Dependency Injection
+
+```csharp
+// Program.cs
+builder.Services.AddScoped<IUserService, UserService>();
+builder.Services.AddScoped<IUserRepository, UserRepository>();
+```
+
+---
+
+## Response Format
+
+```csharp
+public class ApiResponse<T>
+{
+    public bool Success { get; set; }
+    public T? Data { get; set; }
+    public string? Error { get; set; }
+}
+```
+
+---
+
+## HTTP Status Codes
+
+| Method | Success | Error |
+|--------|---------|-------|
+| GET | 200 OK | 404 Not Found |
+| POST | 201 Created | 400 Bad Request |
+| PUT | 200 OK | 404 Not Found |
+| DELETE | 204 No Content | 404 Not Found |
+
+---
+
+## DO / DON'T
+
+| ✅ Do | ❌ Don't |
+|-------|---------|
+| Async/await | Blocking calls |
+| DI everywhere | `new` in controllers |
+| Proper status codes | 200 for everything |

package/template/skills/azure-aks/SKILL.md

@@ -0,0 +1,136 @@
+---
+name: azure-aks
+description: Azure Kubernetes Service deployment patterns
+---
+
+# Azure AKS
+
+> Kubernetes deployment for Azure.
+
+---
+
+## Deployment Manifest
+
+```yaml
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myapp
+  labels:
+    app: myapp
+spec:
+  replicas: 3
+  selector:
+    matchLabels:
+      app: myapp
+  template:
+    metadata:
+      labels:
+        app: myapp
+    spec:
+      containers:
+        - name: myapp
+          image: myacr.azurecr.io/myapp:v1
+          ports:
+            - containerPort: 80
+          resources:
+            requests:
+              memory: "128Mi"
+              cpu: "100m"
+            limits:
+              memory: "256Mi"
+              cpu: "200m"
+```
+
+---
+
+## Service
+
+```yaml
+apiVersion: v1
+kind: Service
+metadata:
+  name: myapp-service
+spec:
+  selector:
+    app: myapp
+  ports:
+    - port: 80
+      targetPort: 80
+  type: LoadBalancer
+```
+
+---
+
+## Ingress
+
+```yaml
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: myapp-ingress
+spec:
+  rules:
+    - host: myapp.example.com
+      http:
+        paths:
+          - path: /
+            pathType: Prefix
+            backend:
+              service:
+                name: myapp-service
+                port:
+                  number: 80
+```
+
+---
+
+## ConfigMap & Secrets
+
+```yaml
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: myapp-config
+data:
+  ENVIRONMENT: "production"
+
+---
+apiVersion: v1
+kind: Secret
+metadata:
+  name: myapp-secrets
+type: Opaque
+data:
+  CONNECTION_STRING: <base64-encoded>
+```
+
+---
+
+## Health Checks
+
+```yaml
+livenessProbe:
+  httpGet:
+    path: /health
+    port: 80
+  initialDelaySeconds: 10
+  periodSeconds: 5
+
+readinessProbe:
+  httpGet:
+    path: /ready
+    port: 80
+  initialDelaySeconds: 5
+  periodSeconds: 3
+```
+
+---
+
+## DO / DON'T
+
+| ✅ Do | ❌ Don't |
+|-------|---------|
+| Resource limits | Unlimited resources |
+| Health checks | Skip probes |
+| Rolling updates | Recreate strategy |