antigravity-devkit 1.0.0 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antigravity-devkit",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "AI DevKit for Vue3 + ASP.NET + Azure development with specialized agents, skills, and workflows",
   "author": "tridp.it@outlook.com",
   "license": "MIT",

package/template/scripts/README.md

@@ -0,0 +1,317 @@
+# Verification Scripts
+
+Automated validation scripts used by agents to ensure code quality, security, and correctness.
+
+---
+
+## Agent → Script Mapping
+
+| Agent | Script | Purpose |
+|-------|--------|---------|
+| `frontend-specialist` | `vitest_runner.py` | Run Vue3/TypeScript tests with Vitest |
+| `backend-specialist` | `xunit_runner.py` | Run ASP.NET/C# tests with xUnit |
+| `database-architect` | `schema_validator.py` | Validate SQL schemas and migrations |
+| `security-auditor` | `security_scan.py` | Scan for security vulnerabilities |
+| **Any agent** | `lint_runner.py` | Universal code quality checker |
+| **Any agent** | `checklist.py` | Quick validation checklist |
+| **Any agent** | `verify_all.py` | Comprehensive validation suite |
+
+---
+
+## Script Output Protocol
+
+When agents use these scripts, they follow this protocol:
+
+1. **Run script** - Execute the appropriate validation script
+2. **Parse errors/warnings** - Extract and categorize issues
+3. **Summarize to user** - Present findings in readable format
+4. **Ask before fixing** - Request approval before making changes
+
+---
+
+## Individual Script Usage
+
+### 🧪 `vitest_runner.py` - Frontend Test Runner
+
+**Purpose**: Execute and validate Vue3/TypeScript tests using Vitest
+
+**Usage**:
+```bash
+# Run tests
+python scripts/vitest_runner.py .
+
+# Run with coverage
+python scripts/vitest_runner.py . --coverage
+
+# Watch mode
+python scripts/vitest_runner.py . --watch
+```
+
+**Requirements**: Node.js, Vitest installed in project
+
+**Output**: Test results, pass/fail counts, coverage metrics
+
+---
+
+### 🧪 `xunit_runner.py` - Backend Test Runner
+
+**Purpose**: Execute and validate ASP.NET/C# tests using xUnit
+
+**Usage**:
+```bash
+# Run all tests
+python scripts/xunit_runner.py .
+
+# Run with coverage
+python scripts/xunit_runner.py . --coverage
+
+# Filter specific tests
+python scripts/xunit_runner.py . --filter "UserServiceTests"
+```
+
+**Requirements**: .NET SDK, xUnit test projects
+
+**Output**: Test results, pass/fail counts, duration
+
+---
+
+### 🗄️ `schema_validator.py` - Database Schema Validator
+
+**Purpose**: Validate SQL Server schemas, migrations, and stored procedures
+
+**Usage**:
+```bash
+# Validate schemas
+python scripts/schema_validator.py .
+
+# With connection string (for live validation)
+python scripts/schema_validator.py . --connection-string "Server=..."
+```
+
+**Checks**:
+- SQL syntax errors
+- Missing primary keys
+- Naming conventions
+- Migration file naming
+- SQL injection risks
+- Transaction handling
+
+**Output**: Schema quality report, syntax issues, recommendations
+
+---
+
+### 🔒 `security_scan.py` - Security Scanner
+
+**Purpose**: Comprehensive security vulnerability detection
+
+**Usage**:
+```bash
+# Full security scan
+python scripts/security_scan.py .
+
+# Filter by severity
+python scripts/security_scan.py . --severity high
+```
+
+**Scans For**:
+- Hardcoded secrets (passwords, API keys, tokens)
+- npm package vulnerabilities
+- NuGet package vulnerabilities
+- SQL injection patterns
+- XSS vulnerabilities
+- Weak cryptography (MD5, SHA1)
+- eval() usage
+- HTTP vs HTTPS
+- Missing security headers (HSTS, HTTPS redirect)
+
+**Output**: Security findings grouped by severity (HIGH/MEDIUM/LOW)
+
+---
+
+### 🔍 `lint_runner.py` - Universal Linter
+
+**Purpose**: Code quality and style validation for both frontend and backend
+
+**Usage**:
+```bash
+# Lint entire project
+python scripts/lint_runner.py .
+
+# Auto-fix issues
+python scripts/lint_runner.py . --fix
+
+# Frontend only
+python scripts/lint_runner.py . --frontend-only
+
+# Backend only
+python scripts/lint_runner.py . --backend-only
+```
+
+**Frontend Checks**:
+- ESLint (JavaScript/TypeScript)
+- Prettier (code formatting)
+- TypeScript type checking
+
+**Backend Checks**:
+- dotnet format (C# formatting)
+- dotnet build with warnings as errors
+
+**Output**: Code quality report with pass/fail status
+
+---
+
+### ✅ `checklist.py` - Quick Validation
+
+**Purpose**: Fast validation checklist for development and pre-commit
+
+**Usage**:
+```bash
+# Run checklist
+python scripts/checklist.py .
+
+# With URL for integration tests
+python scripts/checklist.py . --url http://localhost:3000
+```
+
+**Checks**:
+- Security (secrets, vulnerabilities)
+- Frontend lint
+- Frontend types
+- Frontend tests
+- Backend build
+- Backend tests
+
+**Output**: Pass/fail summary for each check
+
+---
+
+### 🎯 `verify_all.py` - Comprehensive Validation
+
+**Purpose**: Complete validation suite before deployment
+
+**Usage**:
+```bash
+# Full verification
+python scripts/verify_all.py .
+
+# With application URL
+python scripts/verify_all.py . --url http://localhost:3000
+```
+
+**Runs All Checks**:
+- All checklist items
+- Additional deployment validations
+- Integration tests (if URL provided)
+
+**Output**: Comprehensive validation report
+
+---
+
+## When to Use Each Script
+
+| Scenario | Script | Why |
+|----------|--------|-----|
+| Writing Vue components | `vitest_runner.py` | Validate component tests |
+| Writing API endpoints | `xunit_runner.py` | Validate backend tests |
+| Creating migrations | `schema_validator.py` | Ensure schema quality |
+| Before commit | `checklist.py` | Quick validation |
+| Before PR | `lint_runner.py` | Code quality check |
+| Security review | `security_scan.py` | Find vulnerabilities |
+| Before deployment | `verify_all.py` | Complete validation |
+
+---
+
+## Exit Codes
+
+All scripts follow standard exit code conventions:
+
+- **0** - Success (all checks passed)
+- **1** - Failure (issues found)
+
+This allows scripts to be used in CI/CD pipelines:
+
+```bash
+python scripts/checklist.py . && echo "Ready to commit" || echo "Fix issues first"
+```
+
+---
+
+## Integration with Agents
+
+Agents automatically use these scripts when appropriate:
+
+```
+User: "Test my Vue components"
+  ↓
+@test-engineer activates
+  ↓
+Runs: python scripts/vitest_runner.py .
+  ↓
+Parses output and reports to user
+  ↓
+Asks: "Found 2 failing tests. Should I help fix them?"
+```
+
+---
+
+## Requirements
+
+### Python
+- Python 3.7+
+- No external dependencies (uses stdlib only)
+
+### Project Dependencies
+- **Frontend**: Node.js, npm, Vitest (for vitest_runner.py)
+- **Backend**: .NET SDK (for xunit_runner.py)
+- **Database**: SQL files in project (for schema_validator.py)
+
+---
+
+## Adding Custom Validations
+
+To add project-specific validations:
+
+1. Create a new script following the same pattern
+2. Add to the agent's skill or workflow
+3. Update this README with usage instructions
+
+**Example**:
+```python
+#!/usr/bin/env python3
+"""
+Custom Validator - Your specific validation
+"""
+
+def main():
+    # Your validation logic
+    pass
+
+if __name__ == "__main__":
+    main()
+```
+
+---
+
+## Troubleshooting
+
+### "Command not found"
+- Ensure required tools are installed (npm, dotnet, etc.)
+- Check PATH environment variable
+
+### "Permission denied"
+- Make scripts executable: `chmod +x scripts/*.py`
+
+### "Timeout"
+- Scripts timeout after 5 minutes
+- For large projects, consider running specific checks
+
+---
+
+## Contributing
+
+When modifying scripts:
+
+1. Keep exit codes consistent (0 = success, 1 = failure)
+2. Follow the output protocol (run → parse → summarize → ask)
+3. Add timeout handling for long-running commands
+4. Update this README with changes

package/template/scripts/lint_runner.py

@@ -0,0 +1,253 @@
+#!/usr/bin/env python3
+"""
+Lint Runner - Code quality and style checker
+Universal linting script for any agent to validate code quality.
+
+Usage:
+    python lint_runner.py <project_path>
+    python lint_runner.py <project_path> --fix
+    python lint_runner.py <project_path> --frontend-only
+    python lint_runner.py <project_path> --backend-only
+"""
+
+import subprocess
+import sys
+from pathlib import Path
+from typing import Tuple, Dict, Any, List
+
+
+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 after 5 minutes"
+    except FileNotFoundError:
+        return 1, f"Command not found: {cmd[0]}"
+
+
+def detect_project_type(project_path: str) -> Dict[str, bool]:
+    """Detect what types of projects exist."""
+    path = Path(project_path)
+    
+    return {
+        'frontend': (path / "package.json").exists(),
+        'backend': len(list(path.glob("**/*.csproj"))) > 0 or len(list(path.glob("*.sln"))) > 0,
+        'has_eslint': (path / ".eslintrc.js").exists() or (path / ".eslintrc.json").exists() or (path / "eslint.config.js").exists(),
+        'has_prettier': (path / ".prettierrc").exists() or (path / ".prettierrc.json").exists(),
+    }
+
+
+def lint_frontend(project_path: str, fix: bool = False) -> Tuple[int, str, Dict[str, Any]]:
+    """Run frontend linting (ESLint, Prettier, TypeScript)."""
+    results = {
+        'eslint': {'code': None, 'output': ''},
+        'prettier': {'code': None, 'output': ''},
+        'typescript': {'code': None, 'output': ''},
+    }
+    
+    package_json = Path(project_path) / "package.json"
+    if not package_json.exists():
+        return 1, "No package.json found", results
+    
+    # ESLint
+    print("  Running ESLint...")
+    eslint_cmd = ["npm", "run", "lint"]
+    if fix:
+        eslint_cmd.append("--")
+        eslint_cmd.append("--fix")
+    
+    code, output = run_command(eslint_cmd, project_path)
+    results['eslint'] = {'code': code, 'output': output}
+    
+    # TypeScript type checking
+    print("  Running TypeScript type check...")
+    ts_cmd = ["npm", "run", "type-check"]
+    code, output = run_command(ts_cmd, project_path)
+    
+    # If type-check script doesn't exist, try tsc directly
+    if "Missing script" in output or code == 1:
+        code, output = run_command(["npx", "tsc", "--noEmit"], project_path)
+    
+    results['typescript'] = {'code': code, 'output': output}
+    
+    # Prettier (if configured)
+    prettier_config = Path(project_path) / ".prettierrc"
+    if prettier_config.exists() or (Path(project_path) / ".prettierrc.json").exists():
+        print("  Running Prettier...")
+        prettier_cmd = ["npx", "prettier", "--check", "."]
+        if fix:
+            prettier_cmd = ["npx", "prettier", "--write", "."]
+        
+        code, output = run_command(prettier_cmd, project_path)
+        results['prettier'] = {'code': code, 'output': output}
+    
+    # Determine overall status
+    overall_code = 0
+    for tool, result in results.items():
+        if result['code'] is not None and result['code'] != 0:
+            overall_code = 1
+    
+    return overall_code, "Frontend linting completed", results
+
+
+def lint_backend(project_path: str, fix: bool = False) -> Tuple[int, str, Dict[str, Any]]:
+    """Run backend linting (dotnet format)."""
+    results = {
+        'dotnet_format': {'code': None, 'output': ''},
+        'dotnet_build': {'code': None, 'output': ''},
+    }
+    
+    # Check if .NET project exists
+    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 1, "No .NET project found", results
+    
+    # dotnet format
+    print("  Running dotnet format...")
+    format_cmd = ["dotnet", "format"]
+    if not fix:
+        format_cmd.append("--verify-no-changes")
+    
+    code, output = run_command(format_cmd, project_path)
+    results['dotnet_format'] = {'code': code, 'output': output}
+    
+    # dotnet build (for additional warnings)
+    print("  Running dotnet build...")
+    build_cmd = ["dotnet", "build", "/warnaserror"]
+    code, output = run_command(build_cmd, project_path)
+    results['dotnet_build'] = {'code': code, 'output': output}
+    
+    # Determine overall status
+    overall_code = 0
+    for tool, result in results.items():
+        if result['code'] is not None and result['code'] != 0:
+            overall_code = 1
+    
+    return overall_code, "Backend linting completed", results
+
+
+def format_report(project_types: Dict[str, bool], frontend_results: Dict[str, Any], backend_results: Dict[str, Any]) -> str:
+    """Format linting report."""
+    report = []
+    report.append("=" * 60)
+    report.append("🔍 CODE QUALITY REPORT")
+    report.append("=" * 60)
+    
+    report.append("")
+    report.append("📊 Project Type:")
+    if project_types['frontend']:
+        report.append("  ✅ Frontend (Node.js/TypeScript)")
+    if project_types['backend']:
+        report.append("  ✅ Backend (.NET/C#)")
+    
+    # Frontend results
+    if frontend_results:
+        report.append("")
+        report.append("🎨 Frontend Linting:")
+        
+        for tool, result in frontend_results.items():
+            if result['code'] is None:
+                continue
+            
+            status = "✅ PASS" if result['code'] == 0 else "❌ FAIL"
+            report.append(f"  {tool.upper()}: {status}")
+            
+            if result['code'] != 0:
+                # Show first few lines of error
+                error_lines = result['output'].split('\n')[:10]
+                for line in error_lines:
+                    if line.strip():
+                        report.append(f"    {line}")
+    
+    # Backend results
+    if backend_results:
+        report.append("")
+        report.append("⚙️  Backend Linting:")
+        
+        for tool, result in backend_results.items():
+            if result['code'] is None:
+                continue
+            
+            status = "✅ PASS" if result['code'] == 0 else "❌ FAIL"
+            tool_name = tool.replace('_', ' ').title()
+            report.append(f"  {tool_name}: {status}")
+            
+            if result['code'] != 0:
+                # Show first few lines of error
+                error_lines = result['output'].split('\n')[:10]
+                for line in error_lines:
+                    if line.strip():
+                        report.append(f"    {line}")
+    
+    report.append("")
+    report.append("=" * 60)
+    
+    return "\n".join(report)
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python lint_runner.py <project_path> [--fix] [--frontend-only] [--backend-only]")
+        sys.exit(1)
+    
+    project_path = sys.argv[1]
+    fix = "--fix" in sys.argv
+    frontend_only = "--frontend-only" in sys.argv
+    backend_only = "--backend-only" in sys.argv
+    
+    print("🔍 Lint Runner")
+    print("=" * 60)
+    print(f"Project: {project_path}")
+    print(f"Auto-fix: {fix}")
+    print()
+    
+    # Detect project types
+    project_types = detect_project_type(project_path)
+    
+    frontend_results = {}
+    backend_results = {}
+    overall_code = 0
+    
+    # Run frontend linting
+    if project_types['frontend'] and not backend_only:
+        print("Running frontend linting...")
+        code, message, frontend_results = lint_frontend(project_path, fix)
+        if code != 0:
+            overall_code = 1
+        print()
+    
+    # Run backend linting
+    if project_types['backend'] and not frontend_only:
+        print("Running backend linting...")
+        code, message, backend_results = lint_backend(project_path, fix)
+        if code != 0:
+            overall_code = 1
+        print()
+    
+    # Generate report
+    report = format_report(project_types, frontend_results, backend_results)
+    print(report)
+    
+    # Final status
+    if overall_code == 0:
+        print("✅ All linting checks passed!")
+    else:
+        print("❌ Linting issues found")
+        if not fix:
+            print("\nRun with --fix to automatically fix issues")
+    
+    sys.exit(overall_code)
+
+
+if __name__ == "__main__":
+    main()