antigravity-ide 4.2.0 → 4.2.1

package/.agent/scripts/auto_preview.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""
+Auto Preview - Antigravity Kit
+==============================
+Manages (start/stop/status) the local development server for previewing the application.
+
+Usage:
+    python .agent/scripts/auto_preview.py start [port]
+    python .agent/scripts/auto_preview.py stop
+    python .agent/scripts/auto_preview.py status
+"""
+
+import os
+import sys
+import time
+import json
+import signal
+import argparse
+import subprocess
+from pathlib import Path
+
+AGENT_DIR = Path(".agent")
+PID_FILE = AGENT_DIR / "preview.pid"
+LOG_FILE = AGENT_DIR / "preview.log"
+
+def get_project_root():
+    return Path(".").resolve()
+
+def is_running(pid):
+    try:
+        os.kill(pid, 0)
+        return True
+    except OSError:
+        return False
+
+def get_start_command(root):
+    pkg_file = root / "package.json"
+    if not pkg_file.exists():
+        return None
+    
+    with open(pkg_file, 'r') as f:
+        data = json.load(f)
+    
+    scripts = data.get("scripts", {})
+    if "dev" in scripts:
+        return ["npm", "run", "dev"]
+    elif "start" in scripts:
+        return ["npm", "start"]
+    return None
+
+def start_server(port=3000):
+    if PID_FILE.exists():
+        try:
+            pid = int(PID_FILE.read_text().strip())
+            if is_running(pid):
+                print(f"⚠️  Preview already running (PID: {pid})")
+                return
+        except:
+            pass # Invalid PID file
+
+    root = get_project_root()
+    cmd = get_start_command(root)
+    
+    if not cmd:
+        print("❌ No 'dev' or 'start' script found in package.json")
+        sys.exit(1)
+    
+    # Add port env var if needed (simple heuristic)
+    env = os.environ.copy()
+    env["PORT"] = str(port)
+    
+    print(f"🚀 Starting preview on port {port}...")
+    
+    with open(LOG_FILE, "w") as log:
+        process = subprocess.Popen(
+            cmd,
+            cwd=str(root),
+            stdout=log,
+            stderr=log,
+            env=env,
+            shell=True # Required for npm on windows often, or consistent path handling
+        )
+    
+    PID_FILE.write_text(str(process.pid))
+    print(f"✅ Preview started! (PID: {process.pid})")
+    print(f"   Logs: {LOG_FILE}")
+    print(f"   URL: http://localhost:{port}")
+
+def stop_server():
+    if not PID_FILE.exists():
+        print("ℹ️  No preview server found.")
+        return
+
+    try:
+        pid = int(PID_FILE.read_text().strip())
+        if is_running(pid):
+            # Try gentle kill first
+            os.kill(pid, signal.SIGTERM) if sys.platform != 'win32' else subprocess.call(['taskkill', '/F', '/T', '/PID', str(pid)])
+            print(f"🛑 Preview stopped (PID: {pid})")
+        else:
+            print("ℹ️  Process was not running.")
+    except Exception as e:
+        print(f"❌ Error stopping server: {e}")
+    finally:
+        if PID_FILE.exists():
+            PID_FILE.unlink()
+
+def status_server():
+    running = False
+    pid = None
+    url = "Unknown"
+    
+    if PID_FILE.exists():
+        try:
+            pid = int(PID_FILE.read_text().strip())
+            if is_running(pid):
+                running = True
+                # Heuristic for URL, strictly we should save it
+                url = "http://localhost:3000" 
+        except:
+            pass
+            
+    print("\n=== Preview Status ===")
+    if running:
+        print(f"✅ Status: Running")
+        print(f"🔢 PID: {pid}")
+        print(f"🌐 URL: {url} (Likely)")
+        print(f"📝 Logs: {LOG_FILE}")
+    else:
+        print("⚪ Status: Stopped")
+    print("===================\n")
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("action", choices=["start", "stop", "status"])
+    parser.add_argument("port", nargs="?", default="3000")
+    
+    args = parser.parse_args()
+    
+    if args.action == "start":
+        start_server(int(args.port))
+    elif args.action == "stop":
+        stop_server()
+    elif args.action == "status":
+        status_server()
+
+if __name__ == "__main__":
+    main()

package/.agent/scripts/checklist.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+"""
+Master Checklist Runner - Antigravity Kit
+==========================================
+
+Orchestrates all validation scripts in priority order.
+Use this for incremental validation during development.
+
+Usage:
+    python scripts/checklist.py .                    # Run core checks
+    python scripts/checklist.py . --url <URL>        # Include performance checks
+
+Priority Order:
+    P0: Security Scan (vulnerabilities, secrets)
+    P1: Lint & Type Check (code quality)
+    P2: Schema Validation (if database exists)
+    P3: Test Runner (unit/integration tests)
+    P4: UX Audit (psychology laws, accessibility)
+    P5: SEO Check (meta tags, structure)
+    P6: Performance (lighthouse - requires URL)
+"""
+
+import sys
+import subprocess
+import argparse
+from pathlib import Path
+from typing import List, Tuple, Optional
+
+# ANSI colors for terminal output
+class Colors:
+    HEADER = '\033[95m'
+    BLUE = '\033[94m'
+    CYAN = '\033[96m'
+    GREEN = '\033[92m'
+    YELLOW = '\033[93m'
+    RED = '\033[91m'
+    ENDC = '\033[0m'
+    BOLD = '\033[1m'
+
+def print_header(text: str):
+    print(f"\n{Colors.BOLD}{Colors.CYAN}{'='*60}{Colors.ENDC}")
+    print(f"{Colors.BOLD}{Colors.CYAN}{text.center(60)}{Colors.ENDC}")
+    print(f"{Colors.BOLD}{Colors.CYAN}{'='*60}{Colors.ENDC}\n")
+
+def print_step(text: str):
+    print(f"{Colors.BOLD}{Colors.BLUE}🔄 {text}{Colors.ENDC}")
+
+def print_success(text: str):
+    print(f"{Colors.GREEN}✅ {text}{Colors.ENDC}")
+
+def print_warning(text: str):
+    print(f"{Colors.YELLOW}⚠️  {text}{Colors.ENDC}")
+
+def print_error(text: str):
+    print(f"{Colors.RED}❌ {text}{Colors.ENDC}")
+
+# Define priority-ordered checks
+CORE_CHECKS = [
+    ("Security Scan", ".agent/skills/vulnerability-scanner/scripts/security_scan.py", True),
+    ("Lint Check", ".agent/skills/lint-and-validate/scripts/lint_runner.py", True),
+    ("Schema Validation", ".agent/skills/database-design/scripts/schema_validator.py", False),
+    ("Test Runner", ".agent/skills/testing-patterns/scripts/test_runner.py", False),
+    ("UX Audit", ".agent/skills/frontend-design/scripts/ux_audit.py", False),
+    ("SEO Check", ".agent/skills/seo-fundamentals/scripts/seo_checker.py", False),
+]
+
+PERFORMANCE_CHECKS = [
+    ("Lighthouse Audit", ".agent/skills/performance-profiling/scripts/lighthouse_audit.py", True),
+    ("Playwright E2E", ".agent/skills/webapp-testing/scripts/playwright_runner.py", False),
+]
+
+def check_script_exists(script_path: Path) -> bool:
+    """Check if script file exists"""
+    return script_path.exists() and script_path.is_file()
+
+def run_script(name: str, script_path: Path, project_path: str, url: Optional[str] = None) -> dict:
+    """
+    Run a validation script and capture results
+    
+    Returns:
+        dict with keys: name, passed, output, skipped
+    """
+    if not check_script_exists(script_path):
+        print_warning(f"{name}: Script not found, skipping")
+        return {"name": name, "passed": True, "output": "", "skipped": True}
+    
+    print_step(f"Running: {name}")
+    
+    # Build command
+    cmd = ["python", str(script_path), project_path]
+    if url and ("lighthouse" in script_path.name.lower() or "playwright" in script_path.name.lower()):
+        cmd.append(url)
+    
+    # Run script
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=300  # 5 minute timeout
+        )
+        
+        passed = result.returncode == 0
+        
+        if passed:
+            print_success(f"{name}: PASSED")
+        else:
+            print_error(f"{name}: FAILED")
+            if result.stderr:
+                print(f"  Error: {result.stderr[:200]}")
+        
+        return {
+            "name": name,
+            "passed": passed,
+            "output": result.stdout,
+            "error": result.stderr,
+            "skipped": False
+        }
+    
+    except subprocess.TimeoutExpired:
+        print_error(f"{name}: TIMEOUT (>5 minutes)")
+        return {"name": name, "passed": False, "output": "", "error": "Timeout", "skipped": False}
+    
+    except Exception as e:
+        print_error(f"{name}: ERROR - {str(e)}")
+        return {"name": name, "passed": False, "output": "", "error": str(e), "skipped": False}
+
+def run_system_checks(project_path: Path) -> List[dict]:
+    """Run internal system integrity checks"""
+    print_header("🛡️  SYSTEM INTEGRITY")
+    results = []
+    
+    checks = [
+        (".gitattributes", "Cross-platform consistency"),
+        (".editorconfig", "Editor configuration"),
+        ("package.json", "Project manifest"),
+        ("README.md", "Documentation")
+    ]
+    
+    for filename, desc in checks:
+        file_path = project_path / filename
+        exists = file_path.exists() and file_path.is_file()
+        
+        result = {
+            "name": f"System Check: {filename}",
+            "passed": exists,
+            "output": f"Found {filename}" if exists else f"Missing {filename}",
+            "skipped": False
+        }
+        
+        if exists:
+            print_success(f"Found {filename} ({desc})")
+        else:
+            print_error(f"Missing {filename} ({desc})")
+            
+        results.append(result)
+        
+    return results
+
+def print_summary(results: List[dict]):
+    """Print final summary report"""
+    print_header("📊 CHECKLIST SUMMARY")
+    
+    passed_count = sum(1 for r in results if r["passed"] and not r.get("skipped"))
+    failed_count = sum(1 for r in results if not r["passed"] and not r.get("skipped"))
+    skipped_count = sum(1 for r in results if r.get("skipped"))
+    
+    print(f"Total Checks: {len(results)}")
+    print(f"{Colors.GREEN}✅ Passed: {passed_count}{Colors.ENDC}")
+    print(f"{Colors.RED}❌ Failed: {failed_count}{Colors.ENDC}")
+    print(f"{Colors.YELLOW}⏭️  Skipped: {skipped_count}{Colors.ENDC}")
+    print()
+    
+    # Detailed results
+    for r in results:
+        if r.get("skipped"):
+            status = f"{Colors.YELLOW}⏭️ {Colors.ENDC}"
+        elif r["passed"]:
+            status = f"{Colors.GREEN}✅{Colors.ENDC}"
+        else:
+            status = f"{Colors.RED}❌{Colors.ENDC}"
+        
+        print(f"{status} {r['name']}")
+    
+    print()
+    
+    if failed_count > 0:
+        print_error(f"{failed_count} check(s) FAILED - Please fix before proceeding")
+        return False
+    else:
+        print_success("All checks PASSED ✨")
+        return True
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Run Antigravity Kit validation checklist",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python scripts/checklist.py .                      # Core checks only
+  python scripts/checklist.py . --url http://localhost:3000  # Include performance
+        """
+    )
+    parser.add_argument("project", help="Project path to validate")
+    parser.add_argument("--url", help="URL for performance checks (lighthouse, playwright)")
+    parser.add_argument("--skip-performance", action="store_true", help="Skip performance checks even if URL provided")
+    
+    args = parser.parse_args()
+    
+    project_path = Path(args.project).resolve()
+    
+    if not project_path.exists():
+        print_error(f"Project path does not exist: {project_path}")
+        sys.exit(1)
+    
+    print_header("🚀 ANTIGRAVITY KIT - MASTER CHECKLIST")
+    print(f"Project: {project_path}")
+    print(f"URL: {args.url if args.url else 'Not provided (performance checks skipped)'}")
+    
+    results = []
+    
+    # Run System Checks (P0)
+    results.extend(run_system_checks(project_path))
+    
+    # Run core checks
+    print_header("📋 CORE CHECKS")
+    for name, script_path, required in CORE_CHECKS:
+        script = project_path / script_path
+        result = run_script(name, script, str(project_path))
+        results.append(result)
+        
+        # If required check fails, stop
+        if required and not result["passed"] and not result.get("skipped"):
+            print_error(f"CRITICAL: {name} failed. Stopping checklist.")
+            print_summary(results)
+            sys.exit(1)
+    
+    # Run performance checks if URL provided
+    if args.url and not args.skip_performance:
+        print_header("⚡ PERFORMANCE CHECKS")
+        for name, script_path, required in PERFORMANCE_CHECKS:
+            script = project_path / script_path
+            result = run_script(name, script, str(project_path), args.url)
+            results.append(result)
+    
+    # Print summary
+    all_passed = print_summary(results)
+    
+    sys.exit(0 if all_passed else 1)
+
+if __name__ == "__main__":
+    main()

package/.agent/scripts/session_manager.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""
+Session Manager - Antigravity Kit
+=================================
+Analyzes project state, detects tech stack, tracks file statistics, and provides
+a summary of the current session.
+
+Usage:
+    python .agent/scripts/session_manager.py status [path]
+    python .agent/scripts/session_manager.py info [path]
+"""
+
+import os
+import json
+import argparse
+from pathlib import Path
+from typing import Dict, Any, List
+
+def get_project_root(path: str) -> Path:
+    return Path(path).resolve()
+
+def analyze_package_json(root: Path) -> Dict[str, Any]:
+    pkg_file = root / "package.json"
+    if not pkg_file.exists():
+        return {"type": "unknown", "dependencies": {}}
+    
+    try:
+        with open(pkg_file, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+            
+        deps = data.get("dependencies", {})
+        dev_deps = data.get("devDependencies", {})
+        all_deps = {**deps, **dev_deps}
+        
+        stack = []
+        if "next" in all_deps: stack.append("Next.js")
+        elif "react" in all_deps: stack.append("React")
+        elif "vue" in all_deps: stack.append("Vue")
+        elif "svelte" in all_deps: stack.append("Svelte")
+        elif "express" in all_deps: stack.append("Express")
+        elif "nestjs" in all_deps or "@nestjs/core" in all_deps: stack.append("NestJS")
+        
+        if "tailwindcss" in all_deps: stack.append("Tailwind CSS")
+        if "prisma" in all_deps: stack.append("Prisma")
+        if "typescript" in all_deps: stack.append("TypeScript")
+        
+        return {
+            "name": data.get("name", "unnamed"),
+            "version": data.get("version", "0.0.0"),
+            "stack": stack,
+            "scripts": list(data.get("scripts", {}).keys())
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+def count_files(root: Path) -> Dict[str, int]:
+    stats = {"created": 0, "modified": 0, "total": 0}
+    # Simple count for now, comprehensive tracking would require git diff or extensive history
+    exclude = {".git", "node_modules", ".next", "dist", "build", ".agent", ".gemini", "__pycache__"}
+    
+    for root_dir, dirs, files in os.walk(root):
+        dirs[:] = [d for d in dirs if d not in exclude]
+        stats["total"] += len(files)
+        
+    return stats
+
+def detect_features(root: Path) -> List[str]:
+    # Heuristic: look at folder names in src/
+    features = []
+    src = root / "src"
+    if src.exists():
+        possible_dirs = ["components", "modules", "features", "app", "pages", "services"]
+        for d in possible_dirs:
+            p = src / d
+            if p.exists() and p.is_dir():
+                # List subdirectories as likely features
+                for child in p.iterdir():
+                    if child.is_dir():
+                        features.append(child.name)
+    return features[:10] # Limit to top 10
+
+def print_status(root: Path):
+    info = analyze_package_json(root)
+    stats = count_files(root)
+    features = detect_features(root)
+    
+    print("\n=== Project Status ===")
+    print(f"\n📁 Project: {info.get('name', root.name)}")
+    print(f"📂 Path: {root}")
+    print(f"🏷️  Type: {', '.join(info.get('stack', ['Generic']))}")
+    print(f"📊 Status: Active")
+    
+    print("\n🔧 Tech Stack:")
+    for tech in info.get('stack', []):
+        print(f"   • {tech}")
+        
+    print(f"\n✅ Detected Modules/Features ({len(features)}):")
+    for feat in features:
+        print(f"   • {feat}")
+    if not features:
+        print("   (No distinct feature modules detected)")
+        
+    print(f"\n📄 Files: {stats['total']} total files tracked")
+    print("\n====================\n")
+
+def main():
+    parser = argparse.ArgumentParser(description="Session Manager")
+    parser.add_argument("command", choices=["status", "info"], help="Command to run")
+    parser.add_argument("path", nargs="?", default=".", help="Project path")
+    
+    args = parser.parse_args()
+    root = get_project_root(args.path)
+    
+    if args.command == "status":
+        print_status(root)
+    elif args.command == "info":
+        print(json.dumps(analyze_package_json(root), indent=2))
+
+if __name__ == "__main__":
+    main()

package/.agent/scripts/simulation_install.js

@@ -0,0 +1,59 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+const SOURCE_AGENT = path.join(__dirname, '..');
+const DEST_ROOT = path.join(__dirname, '../../test_install_simulation');
+const DEST_AGENT = path.join(DEST_ROOT, '.agent');
+
+async function simulateInstall() {
+  console.log('📦 Simulating "Full Install" Copy Logic...');
+  console.log(`Source: ${SOURCE_AGENT}`);
+  console.log(`Dest:   ${DEST_AGENT}`);
+
+  // Cleanup prev run
+  fs.removeSync(DEST_ROOT);
+  fs.mkdirSync(DEST_AGENT, { recursive: true });
+
+  // 1. Replicate copyBaseStructure Loop from cli/create.js
+  const entries = fs.readdirSync(SOURCE_AGENT, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    if (entry.name === 'skills' || entry.name === 'GEMINI.md' || entry.name === 'START_HERE.md' || entry.name === 'node_modules' || entry.name === 'scripts') {
+      continue; 
+    }
+    
+    const srcPath = path.join(SOURCE_AGENT, entry.name);
+    const destPath = path.join(DEST_AGENT, entry.name);
+    
+    console.log(`Copying ${entry.name}...`);
+    await fs.copy(srcPath, destPath);
+  }
+
+  // 2. Verify .shared exists in Destination
+  const sharedDest = path.join(DEST_AGENT, '.shared');
+  if (fs.existsSync(sharedDest)) {
+    console.log('✅ .shared folder copied successfully.');
+    
+    // Check specific deep file
+    const deepFile = path.join(sharedDest, 'design-philosophy/presets/linear_glow.json');
+    if (fs.existsSync(deepFile)) {
+        console.log('✅ Deep checking: linear_glow.json exists.');
+        console.log('🎉 VERIFICATION PASSED: Full install will include shared modules.');
+    } else {
+        console.error('❌ Deep checking FAILED: Content missing inside .shared');
+        process.exit(1);
+    }
+
+  } else {
+    console.error('❌ .shared folder FAILED to copy.');
+    process.exit(1);
+  }
+
+  // Cleanup
+  fs.removeSync(DEST_ROOT);
+}
+
+simulateInstall().catch(err => {
+    console.error(err);
+    process.exit(1);
+});

package/.agent/scripts/sync_to_global.py

@@ -0,0 +1,78 @@
+import os
+import shutil
+import sys
+from pathlib import Path
+
+def sync_to_global():
+    # 1. Setup paths
+    workspace_agent_dir = Path("d:/Github/google-antigravity/.agent")
+    global_dir = Path(os.path.expanduser("~/.antigravity"))
+    
+    if not workspace_agent_dir.exists():
+        print(f"Error: Workspace agent directory not found at {workspace_agent_dir}")
+        return
+
+    # Define what to sync: (Source relative to .agent, Destination relative to ~/.antigravity)
+    sync_map = {
+        "rules": "rules",
+        "workflows": "workflows",
+        "agents": "agents",
+        "skills/ai-engineer": "skills/ai-engineer",
+        "skills/security-auditor": "skills/security-auditor",
+        "skills/performance-engineer": "skills/performance-engineer",
+        "skills/modern-web-architect": "skills/modern-web-architect",
+        "skills/seo-expert-kit": "skills/seo-expert-kit",
+        "skills/tdd-master-workflow": "skills/tdd-master-workflow",
+        "skills/production-code-audit": "skills/production-code-audit",
+        "skills/cro-expert-kit": "skills/cro-expert-kit",
+        "skills/cloud-architect-master": "skills/cloud-architect-master",
+        "skills/database-migration": "skills/database-migration",
+        "skills/penetration-tester-master": "skills/penetration-tester-master",
+        "skills/git-collaboration-master": "skills/git-collaboration-master",
+        "skills/deployment-engineer": "skills/deployment-engineer",
+        "skills/api-documenter": "skills/api-documenter",
+        "skills/full-stack-scaffold": "skills/full-stack-scaffold",
+        "skills/incident-responder": "skills/incident-responder",
+        "skills/legacy-modernizer": "skills/legacy-modernizer",
+        ".shared/database-master": ".shared/database-master",
+        ".shared/metrics": ".shared/metrics",
+        ".shared/api-standards": ".shared/api-standards",
+        ".shared/i18n-master": ".shared/i18n-master",
+        ".shared/ai-master": ".shared/ai-master",
+        ".shared/domain-blueprints": ".shared/domain-blueprints",
+        ".shared/security-armor": ".shared/security-armor",
+        ".shared/testing-master": ".shared/testing-master",
+        ".shared/infra-blueprints": ".shared/infra-blueprints",
+        ".shared/vitals-templates": ".shared/vitals-templates",
+        ".shared/design-system": ".shared/design-system",
+        ".shared/compliance": ".shared/compliance",
+        "core": "core",
+    }
+
+    print(f"🚀 Starting Sync from Workspace to Global (~/.antigravity)...")
+
+    for src_rel, dest_rel in sync_map.items():
+        src_path = workspace_agent_dir / src_rel
+        dest_path = global_dir / dest_rel
+        
+        if src_path.exists():
+            # Create parent dirs for destination
+            dest_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            if src_path.is_dir():
+                # Remove dest if exists to ensure clean sync
+                if dest_path.exists():
+                    shutil.rmtree(dest_path)
+                shutil.copytree(src_path, dest_path)
+                print(f"✅ Synced Directory: {src_rel} -> Global")
+            else:
+                shutil.copy2(src_path, dest_path)
+                print(f"✅ Synced File: {src_rel} -> Global")
+        else:
+            print(f"⚠️ Warning: Source {src_rel} not found in workspace.")
+
+    print(f"\n✨ Global Synchronization Complete!")
+    print(f"Your global Antigravity IDE is now powered by this project's Master Skills and Rules.")
+
+if __name__ == "__main__":
+    sync_to_global()