@ruyfranca/myskills 1.0.17 → 1.0.19

package/.agent/rules/GEMINI.md

@@ -0,0 +1,273 @@
+---
+trigger: always_on
+---
+
+# GEMINI.md - Antigravity Kit
+
+> This file defines how the AI behaves in this workspace.
+
+---
+
+## CRITICAL: AGENT & SKILL PROTOCOL (START HERE)
+
+> **MANDATORY:** You MUST read the appropriate agent file and its skills BEFORE performing any implementation. This is the highest priority rule.
+
+### 1. Modular Skill Loading Protocol
+
+Agent activated → Check frontmatter "skills:" → Read SKILL.md (INDEX) → Read specific sections.
+
+- **Selective Reading:** DO NOT read ALL files in a skill folder. Read `SKILL.md` first, then only read sections matching the user's request.
+- **Rule Priority:** P0 (GEMINI.md) > P1 (Agent .md) > P2 (SKILL.md). All rules are binding.
+
+### 2. Enforcement Protocol
+
+1. **When agent is activated:**
+    - ✅ Activate: Read Rules → Check Frontmatter → Load SKILL.md → Apply All.
+2. **Forbidden:** Never skip reading agent rules or skill instructions. "Read → Understand → Apply" is mandatory.
+
+---
+
+## 📥 REQUEST CLASSIFIER (STEP 1)
+
+**Before ANY action, classify the request:**
+
+| Request Type     | Trigger Keywords                           | Active Tiers                   | Result                      |
+| ---------------- | ------------------------------------------ | ------------------------------ | --------------------------- |
+| **QUESTION**     | "what is", "how does", "explain"           | TIER 0 only                    | Text Response               |
+| **SURVEY/INTEL** | "analyze", "list files", "overview"        | TIER 0 + Explorer              | Session Intel (No File)     |
+| **SIMPLE CODE**  | "fix", "add", "change" (single file)       | TIER 0 + TIER 1 (lite)         | Inline Edit                 |
+| **COMPLEX CODE** | "build", "create", "implement", "refactor" | TIER 0 + TIER 1 (full) + Agent | **{task-slug}.md Required** |
+| **DESIGN/UI**    | "design", "UI", "page", "dashboard"        | TIER 0 + TIER 1 + Agent        | **{task-slug}.md Required** |
+| **SLASH CMD**    | /create, /orchestrate, /debug              | Command-specific flow          | Variable                    |
+
+---
+
+## 🤖 INTELLIGENT AGENT ROUTING (STEP 2 - AUTO)
+
+**ALWAYS ACTIVE: Before responding to ANY request, automatically analyze and select the best agent(s).**
+
+> 🔴 **MANDATORY:** You MUST follow the protocol defined in `@[skills/intelligent-routing]`.
+
+### Auto-Selection Protocol
+
+1. **Analyze (Silent)**: Detect domains (Frontend, Backend, Security, etc.) from user request.
+2. **Select Agent(s)**: Choose the most appropriate specialist(s).
+3. **Inform User**: Concisely state which expertise is being applied.
+4. **Apply**: Generate response using the selected agent's persona and rules.
+
+### Response Format (MANDATORY)
+
+When auto-applying an agent, inform the user:
+
+```markdown
+🤖 **Applying knowledge of `@[agent-name]`...**
+
+[Continue with specialized response]
+```
+
+**Rules:**
+
+1. **Silent Analysis**: No verbose meta-commentary ("I am analyzing...").
+2. **Respect Overrides**: If user mentions `@agent`, use it.
+3. **Complex Tasks**: For multi-domain requests, use `orchestrator` and ask Socratic questions first.
+
+### ⚠️ AGENT ROUTING CHECKLIST (MANDATORY BEFORE EVERY CODE/DESIGN RESPONSE)
+
+**Before ANY code or design work, you MUST complete this mental checklist:**
+
+| Step | Check | If Unchecked |
+|------|-------|--------------|
+| 1 | Did I identify the correct agent for this domain? | → STOP. Analyze request domain first. |
+| 2 | Did I READ the agent's `.md` file (or recall its rules)? | → STOP. Open `.agent/agents/{agent}.md` |
+| 3 | Did I announce `🤖 Applying knowledge of @[agent]...`? | → STOP. Add announcement before response. |
+| 4 | Did I load required skills from agent's frontmatter? | → STOP. Check `skills:` field and read them. |
+
+**Failure Conditions:**
+
+- ❌ Writing code without identifying an agent = **PROTOCOL VIOLATION**
+- ❌ Skipping the announcement = **USER CANNOT VERIFY AGENT WAS USED**
+- ❌ Ignoring agent-specific rules (e.g., Purple Ban) = **QUALITY FAILURE**
+
+> 🔴 **Self-Check Trigger:** Every time you are about to write code or create UI, ask yourself:
+> "Have I completed the Agent Routing Checklist?" If NO → Complete it first.
+
+---
+
+## TIER 0: UNIVERSAL RULES (Always Active)
+
+### 🌐 Language Handling
+
+When user's prompt is NOT in English:
+
+1. **Internally translate** for better comprehension
+2. **Respond in user's language** - match their communication
+3. **Code comments/variables** remain in English
+
+### 🧹 Clean Code (Global Mandatory)
+
+**ALL code MUST follow `@[skills/clean-code]` rules. No exceptions.**
+
+- **Code**: Concise, direct, no over-engineering. Self-documenting.
+- **Testing**: Mandatory. Pyramid (Unit > Int > E2E) + AAA Pattern.
+- **Performance**: Measure first. Adhere to 2025 standards (Core Web Vitals).
+- **Infra/Safety**: 5-Phase Deployment. Verify secrets security.
+
+### 📁 File Dependency Awareness
+
+**Before modifying ANY file:**
+
+1. Check `CODEBASE.md` → File Dependencies
+2. Identify dependent files
+3. Update ALL affected files together
+
+### 🗺️ System Map Read
+
+> 🔴 **MANDATORY:** Read `ARCHITECTURE.md` at session start to understand Agents, Skills, and Scripts.
+
+**Path Awareness:**
+
+- Agents: `.agent/` (Project)
+- Skills: `.agent/skills/` (Project)
+- Runtime Scripts: `.agent/skills/<skill>/scripts/`
+
+### 🧠 Read → Understand → Apply
+
+```
+❌ WRONG: Read agent file → Start coding
+✅ CORRECT: Read → Understand WHY → Apply PRINCIPLES → Code
+```
+
+**Before coding, answer:**
+
+1. What is the GOAL of this agent/skill?
+2. What PRINCIPLES must I apply?
+3. How does this DIFFER from generic output?
+
+---
+
+## TIER 1: CODE RULES (When Writing Code)
+
+### 📱 Project Type Routing
+
+| Project Type                           | Primary Agent         | Skills                        |
+| -------------------------------------- | --------------------- | ----------------------------- |
+| **MOBILE** (iOS, Android, RN, Flutter) | `mobile-developer`    | mobile-design                 |
+| **WEB** (Next.js, React web)           | `frontend-specialist` | frontend-design               |
+| **BACKEND** (API, server, DB)          | `backend-specialist`  | api-patterns, database-design |
+
+> 🔴 **Mobile + frontend-specialist = WRONG.** Mobile = mobile-developer ONLY.
+
+### 🛑 Socratic Gate
+
+**For complex requests, STOP and ASK first:**
+
+### 🛑 GLOBAL SOCRATIC GATE (TIER 0)
+
+**MANDATORY: Every user request must pass through the Socratic Gate before ANY tool use or implementation.**
+
+| Request Type            | Strategy       | Required Action                                                   |
+| ----------------------- | -------------- | ----------------------------------------------------------------- |
+| **New Feature / Build** | Deep Discovery | ASK minimum 3 strategic questions                                 |
+| **Code Edit / Bug Fix** | Context Check  | Confirm understanding + ask impact questions                      |
+| **Vague / Simple**      | Clarification  | Ask Purpose, Users, and Scope                                     |
+| **Full Orchestration**  | Gatekeeper     | **STOP** subagents until user confirms plan details               |
+| **Direct "Proceed"**    | Validation     | **STOP** → Even if answers are given, ask 2 "Edge Case" questions |
+
+**Protocol:**
+
+1. **Never Assume:** If even 1% is unclear, ASK.
+2. **Handle Spec-heavy Requests:** When user gives a list (Answers 1, 2, 3...), do NOT skip the gate. Instead, ask about **Trade-offs** or **Edge Cases** (e.g., "LocalStorage confirmed, but should we handle data clearing or versioning?") before starting.
+3. **Wait:** Do NOT invoke subagents or write code until the user clears the Gate.
+4. **Reference:** Full protocol in `@[skills/brainstorming]`.
+
+### 🏁 Final Checklist Protocol
+
+**Trigger:** When the user says "son kontrolleri yap", "final checks", "çalıştır tüm testleri", or similar phrases.
+
+| Task Stage       | Command                                            | Purpose                        |
+| ---------------- | -------------------------------------------------- | ------------------------------ |
+| **Manual Audit** | `python .agent/scripts/checklist.py .`             | Priority-based project audit   |
+| **Pre-Deploy**   | `python .agent/scripts/checklist.py . --url <URL>` | Full Suite + Performance + E2E |
+
+**Priority Execution Order:**
+
+1. **Security** → 2. **Lint** → 3. **Schema** → 4. **Tests** → 5. **UX** → 6. **Seo** → 7. **Lighthouse/E2E**
+
+**Rules:**
+
+- **Completion:** A task is NOT finished until `checklist.py` returns success.
+- **Reporting:** If it fails, fix the **Critical** blockers first (Security/Lint).
+
+**Available Scripts (12 total):**
+
+| Script                     | Skill                 | When to Use         |
+| -------------------------- | --------------------- | ------------------- |
+| `security_scan.py`         | vulnerability-scanner | Always on deploy    |
+| `dependency_analyzer.py`   | vulnerability-scanner | Weekly / Deploy     |
+| `lint_runner.py`           | lint-and-validate     | Every code change   |
+| `test_runner.py`           | testing-patterns      | After logic change  |
+| `schema_validator.py`      | database-design       | After DB change     |
+| `ux_audit.py`              | frontend-design       | After UI change     |
+| `accessibility_checker.py` | frontend-design       | After UI change     |
+| `seo_checker.py`           | seo-fundamentals      | After page change   |
+| `bundle_analyzer.py`       | performance-profiling | Before deploy       |
+| `mobile_audit.py`          | mobile-design         | After mobile change |
+| `lighthouse_audit.py`      | performance-profiling | Before deploy       |
+| `playwright_runner.py`     | webapp-testing        | Before deploy       |
+
+> 🔴 **Agents & Skills can invoke ANY script** via `python .agent/skills/<skill>/scripts/<script>.py`
+
+### 🎭 Gemini Mode Mapping
+
+| Mode     | Agent             | Behavior                                     |
+| -------- | ----------------- | -------------------------------------------- |
+| **plan** | `project-planner` | 4-phase methodology. NO CODE before Phase 4. |
+| **ask**  | -                 | Focus on understanding. Ask questions.       |
+| **edit** | `orchestrator`    | Execute. Check `{task-slug}.md` first.       |
+
+**Plan Mode (4-Phase):**
+
+1. ANALYSIS → Research, questions
+2. PLANNING → `{task-slug}.md`, task breakdown
+3. SOLUTIONING → Architecture, design (NO CODE!)
+4. IMPLEMENTATION → Code + tests
+
+> 🔴 **Edit mode:** If multi-file or structural change → Offer to create `{task-slug}.md`. For single-file fixes → Proceed directly.
+
+---
+
+## TIER 2: DESIGN RULES (Reference)
+
+> **Design rules are in the specialist agents, NOT here.**
+
+| Task         | Read                            |
+| ------------ | ------------------------------- |
+| Web UI/UX    | `.agent/frontend-specialist.md` |
+| Mobile UI/UX | `.agent/mobile-developer.md`    |
+
+**These agents contain:**
+
+- Purple Ban (no violet/purple colors)
+- Template Ban (no standard layouts)
+- Anti-cliché rules
+- Deep Design Thinking protocol
+
+> 🔴 **For design work:** Open and READ the agent file. Rules are there.
+
+---
+
+## 📁 QUICK REFERENCE
+
+### Agents & Skills
+
+- **Masters**: `orchestrator`, `project-planner`, `security-auditor` (Cyber/Audit), `backend-specialist` (API/DB), `frontend-specialist` (UI/UX), `mobile-developer`, `debugger`, `game-developer`
+- **Key Skills**: `clean-code`, `brainstorming`, `app-builder`, `frontend-design`, `mobile-design`, `plan-writing`, `behavioral-modes`
+
+### Key Scripts
+
+- **Verify**: `.agent/scripts/verify_all.py`, `.agent/scripts/checklist.py`
+- **Scanners**: `security_scan.py`, `dependency_analyzer.py`
+- **Audits**: `ux_audit.py`, `mobile_audit.py`, `lighthouse_audit.py`, `seo_checker.py`
+- **Test**: `playwright_runner.py`, `test_runner.py`
+
+---

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,217 @@
+#!/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 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 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/verify_all.py

@@ -0,0 +1,327 @@
+#!/usr/bin/env python3
+"""
+Full Verification Suite - Antigravity Kit
+==========================================
+
+Runs COMPLETE validation including all checks + performance + E2E.
+Use this before deployment or major releases.
+
+Usage:
+    python scripts/verify_all.py . --url <URL>
+
+Includes ALL checks:
+    ✅ Security Scan (OWASP, secrets, dependencies)
+    ✅ Lint & Type Coverage
+    ✅ Schema Validation
+    ✅ Test Suite (unit + integration)
+    ✅ UX Audit (psychology, accessibility)
+    ✅ SEO Check
+    ✅ Lighthouse (Core Web Vitals)
+    ✅ Playwright E2E
+    ✅ Bundle Analysis (if applicable)
+    ✅ Mobile Audit (if applicable)
+"""
+
+import sys
+import subprocess
+import argparse
+from pathlib import Path
+from typing import List, Dict, Optional
+from datetime import datetime
+
+# ANSI colors
+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}{'='*70}{Colors.ENDC}")
+    print(f"{Colors.BOLD}{Colors.CYAN}{text.center(70)}{Colors.ENDC}")
+    print(f"{Colors.BOLD}{Colors.CYAN}{'='*70}{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}")
+
+# Complete verification suite
+VERIFICATION_SUITE = [
+    # P0: Security (CRITICAL)
+    {
+        "category": "Security",
+        "checks": [
+            ("Security Scan", ".agent/skills/vulnerability-scanner/scripts/security_scan.py", True),
+            ("Dependency Analysis", ".agent/skills/vulnerability-scanner/scripts/dependency_analyzer.py", False),
+        ]
+    },
+    
+    # P1: Code Quality (CRITICAL)
+    {
+        "category": "Code Quality",
+        "checks": [
+            ("Lint Check", ".agent/skills/lint-and-validate/scripts/lint_runner.py", True),
+            ("Type Coverage", ".agent/skills/lint-and-validate/scripts/type_coverage.py", False),
+        ]
+    },
+    
+    # P2: Data Layer
+    {
+        "category": "Data Layer",
+        "checks": [
+            ("Schema Validation", ".agent/skills/database-design/scripts/schema_validator.py", False),
+        ]
+    },
+    
+    # P3: Testing
+    {
+        "category": "Testing",
+        "checks": [
+            ("Test Suite", ".agent/skills/testing-patterns/scripts/test_runner.py", False),
+        ]
+    },
+    
+    # P4: UX & Accessibility
+    {
+        "category": "UX & Accessibility",
+        "checks": [
+            ("UX Audit", ".agent/skills/frontend-design/scripts/ux_audit.py", False),
+            ("Accessibility Check", ".agent/skills/frontend-design/scripts/accessibility_checker.py", False),
+        ]
+    },
+    
+    # P5: SEO & Content
+    {
+        "category": "SEO & Content",
+        "checks": [
+            ("SEO Check", ".agent/skills/seo-fundamentals/scripts/seo_checker.py", False),
+            ("GEO Check", ".agent/skills/geo-fundamentals/scripts/geo_checker.py", False),
+        ]
+    },
+    
+    # P6: Performance (requires URL)
+    {
+        "category": "Performance",
+        "requires_url": True,
+        "checks": [
+            ("Lighthouse Audit", ".agent/skills/performance-profiling/scripts/lighthouse_audit.py", True),
+            ("Bundle Analysis", ".agent/skills/performance-profiling/scripts/bundle_analyzer.py", False),
+        ]
+    },
+    
+    # P7: E2E Testing (requires URL)
+    {
+        "category": "E2E Testing",
+        "requires_url": True,
+        "checks": [
+            ("Playwright E2E", ".agent/skills/webapp-testing/scripts/playwright_runner.py", False),
+        ]
+    },
+    
+    # P8: Mobile (if applicable)
+    {
+        "category": "Mobile",
+        "checks": [
+            ("Mobile Audit", ".agent/skills/mobile-design/scripts/mobile_audit.py", False),
+        ]
+    },
+    
+    # P9: Internationalization
+    {
+        "category": "Internationalization",
+        "checks": [
+            ("i18n Check", ".agent/skills/i18n-localization/scripts/i18n_checker.py", False),
+        ]
+    },
+]
+
+def run_script(name: str, script_path: Path, project_path: str, url: Optional[str] = None) -> dict:
+    """Run validation script"""
+    if not script_path.exists():
+        print_warning(f"{name}: Script not found, skipping")
+        return {"name": name, "passed": True, "skipped": True, "duration": 0}
+    
+    print_step(f"Running: {name}")
+    start_time = datetime.now()
+    
+    # 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
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=600  # 10 minute timeout for slow checks
+        )
+        
+        duration = (datetime.now() - start_time).total_seconds()
+        passed = result.returncode == 0
+        
+        if passed:
+            print_success(f"{name}: PASSED ({duration:.1f}s)")
+        else:
+            print_error(f"{name}: FAILED ({duration:.1f}s)")
+            if result.stderr:
+                print(f"  {result.stderr[:300]}")
+        
+        return {
+            "name": name,
+            "passed": passed,
+            "output": result.stdout,
+            "error": result.stderr,
+            "skipped": False,
+            "duration": duration
+        }
+    
+    except subprocess.TimeoutExpired:
+        duration = (datetime.now() - start_time).total_seconds()
+        print_error(f"{name}: TIMEOUT (>{duration:.0f}s)")
+        return {"name": name, "passed": False, "skipped": False, "duration": duration, "error": "Timeout"}
+    
+    except Exception as e:
+        duration = (datetime.now() - start_time).total_seconds()
+        print_error(f"{name}: ERROR - {str(e)}")
+        return {"name": name, "passed": False, "skipped": False, "duration": duration, "error": str(e)}
+
+def print_final_report(results: List[dict], start_time: datetime):
+    """Print comprehensive final report"""
+    total_duration = (datetime.now() - start_time).total_seconds()
+    
+    print_header("📊 FULL VERIFICATION REPORT")
+    
+    # Statistics
+    total = len(results)
+    passed = sum(1 for r in results if r["passed"] and not r.get("skipped"))
+    failed = sum(1 for r in results if not r["passed"] and not r.get("skipped"))
+    skipped = sum(1 for r in results if r.get("skipped"))
+    
+    print(f"Total Duration: {total_duration:.1f}s")
+    print(f"Total Checks: {total}")
+    print(f"{Colors.GREEN}✅ Passed: {passed}{Colors.ENDC}")
+    print(f"{Colors.RED}❌ Failed: {failed}{Colors.ENDC}")
+    print(f"{Colors.YELLOW}⏭️  Skipped: {skipped}{Colors.ENDC}")
+    print()
+    
+    # Category breakdown
+    print(f"{Colors.BOLD}Results by Category:{Colors.ENDC}")
+    current_category = None
+    for r in results:
+        # Print category header if changed
+        if r.get("category") and r["category"] != current_category:
+            current_category = r["category"]
+            print(f"\n{Colors.BOLD}{Colors.CYAN}{current_category}:{Colors.ENDC}")
+        
+        # Print result
+        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}"
+        
+        duration_str = f"({r.get('duration', 0):.1f}s)" if not r.get("skipped") else ""
+        print(f"  {status} {r['name']} {duration_str}")
+    
+    print()
+    
+    # Failed checks detail
+    if failed > 0:
+        print(f"{Colors.BOLD}{Colors.RED}❌ FAILED CHECKS:{Colors.ENDC}")
+        for r in results:
+            if not r["passed"] and not r.get("skipped"):
+                print(f"\n{Colors.RED}✗ {r['name']}{Colors.ENDC}")
+                if r.get("error"):
+                    error_preview = r["error"][:200]
+                    print(f"  Error: {error_preview}")
+        print()
+    
+    # Final verdict
+    if failed > 0:
+        print_error(f"VERIFICATION FAILED - {failed} check(s) need attention")
+        print(f"\n{Colors.YELLOW}💡 Tip: Fix critical (security, lint) issues first{Colors.ENDC}")
+        return False
+    else:
+        print_success("✨ ALL CHECKS PASSED - Ready for deployment! ✨")
+        return True
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Run complete Antigravity Kit verification suite",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python scripts/verify_all.py . --url http://localhost:3000
+  python scripts/verify_all.py . --url https://staging.example.com --no-e2e
+        """
+    )
+    parser.add_argument("project", help="Project path to validate")
+    parser.add_argument("--url", required=True, help="URL for performance & E2E checks")
+    parser.add_argument("--no-e2e", action="store_true", help="Skip E2E tests")
+    parser.add_argument("--stop-on-fail", action="store_true", help="Stop on first failure")
+    
+    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 - FULL VERIFICATION SUITE")
+    print(f"Project: {project_path}")
+    print(f"URL: {args.url}")
+    print(f"Started: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    
+    start_time = datetime.now()
+    results = []
+    
+    # Run all verification categories
+    for suite in VERIFICATION_SUITE:
+        category = suite["category"]
+        requires_url = suite.get("requires_url", False)
+        
+        # Skip if requires URL and not provided
+        if requires_url and not args.url:
+            continue
+        
+        # Skip E2E if flag set
+        if args.no_e2e and category == "E2E Testing":
+            continue
+        
+        print_header(f"📋 {category.upper()}")
+        
+        for name, script_path, required in suite["checks"]:
+            script = project_path / script_path
+            result = run_script(name, script, str(project_path), args.url)
+            result["category"] = category
+            results.append(result)
+            
+            # Stop on critical failure if flag set
+            if args.stop_on_fail and required and not result["passed"] and not result.get("skipped"):
+                print_error(f"CRITICAL: {name} failed. Stopping verification.")
+                print_final_report(results, start_time)
+                sys.exit(1)
+    
+    # Print final report
+    all_passed = print_final_report(results, start_time)
+    
+    sys.exit(0 if all_passed else 1)
+
+if __name__ == "__main__":
+    main()

package/.agent/skills/figma-dev-mode/SKILL.md

@@ -0,0 +1,76 @@
+---
+name: figma-dev-mode
+description: Setup and utilization of the Figma Dev Mode MCP to inspect components, layouts, and styles directly from Figma design files.
+allowed-tools: Read, Write, Edit, Glob, run_command
+---
+
+# Figma Dev Mode MCP
+
+> Integrate UI design precisely measuring and extracting information directly from Figma directly through the Dev Mode MCP.
+
+## 🎯 Selective Reading Rule
+
+**Read ONLY files relevant to the request!** If you just need to query nodes, you don't need to read setup.
+
+---
+
+## 📑 Content Map
+
+| Context | Action |
+|---------|--------|
+| Project has no `.mcp.json` | Create `.mcp.json` with Figma MCP config |
+| Analyzing UI/UX | Use MCP to inspect Figma Node IDs |
+| Translating to Code | Extract CSS/Tailwind properties from Figma |
+
+---
+
+## 🔌 Setup Config
+
+To enable the Figma MCP into the project, the following `.mcp.json` block must be present in the user's project root:
+
+```json
+{
+  "mcpServers": {
+    "Figma Dev Mode MCP": {
+      "url": "http://127.0.0.1:3845/mcp"
+    }
+  }
+}
+```
+
+> **Requirements:** The user MUST have the Figma Desktop App running locally with Dev Mode enabled for the MCP to work.
+
+---
+
+## 🔗 Related Skills
+
+| Need | Skill |
+|------|-------|
+| Frontend implementation | `@[skills/senior-frontend]` |
+| Design Systems | `@[skills/ui-design-system]` |
+| UI/UX Best practices | `@[skills/ui-ux-pro-max]` |
+
+---
+
+## ✅ Integration Checklist
+
+Before implementing a design from Figma:
+
+- [ ] **Figma Desktop is running?** (Remind the user if MCP connection fails)
+- [ ] **Figma Node URL/ID provided?** (Ask the user for the specific Figma frame link)
+- [ ] **Selected the correct framework?** (Tailwind, Vanilla CSS, React Native)
+- [ ] **Extracted exact tokens?** (Colors, border-radii, spacing)
+
+---
+
+## ❌ Anti-Patterns
+
+**DON'T:**
+- Guess dimensions and colors when the Figma link is provided.
+- Fail silently if the MCP connection drops (tell the user to open Figma).
+- Extract hardcoded colors without checking if they belong to a Design System's token.
+
+**DO:**
+- Use the MCP to precisely query the layout properties.
+- Map Figma styles to tailwind config variables when possible.
+- Remind the user to open the specific project in Figma Desktop.

package/.agent/workflows/figma.md

@@ -0,0 +1,10 @@
+---
+description: Start Figma Dev Mode MCP integration and UI design translation
+---
+
+# Figma Workflow
+
+1. Configure the `.mcp.json` in the user's project to point to the Figma MCP at `http://127.0.0.1:3845/mcp`.
+2. Instruct the user to open the Figma Desktop app and ensure the design file is active.
+3. Ask the user for the specific Figma URL or Node ID they want to implement.
+4. Call `@[skills/figma-dev-mode]` and `@[skills/senior-frontend]` to begin extraction and implementation.

package/.mcp.json

@@ -0,0 +1,7 @@
+{
+  "mcpServers": {
+    "Figma Dev Mode MCP": {
+      "url": "http://127.0.0.1:3845/mcp"
+    }
+  }
+}

package/README.md

@@ -99,6 +99,12 @@ Especialista em otimização para mecanismos de busca:
 Inteligência avançada de design e experiência do usuário:
 - **Design System**: Gerador de sistemas de design com base em indústria e estilo.
 
+### [Figma Dev Mode](file:///Users/ruy/Code/mySkills/.agent/skills/figma-dev-mode/SKILL.md)
+Integração direta com o Figma através do Model Context Protocol (MCP):
+- **Extração**: Inspeção de nós visuais, tokens de cor, tipografia e espaçamento.
+- **Integração**: Configuração de `.mcp.json` para conectar o Claude/Cursor ao Figma Desktop.
+- **Workflow**: Tradução perfeita do design para código.
+
 ---
 ## 📚 Mais de 70 Skills Especializadas!
 A biblioteca foi expandida massivamente com recursos do Antigravity Kit. Algumas novas categorias incluem:
@@ -120,6 +126,22 @@ Agora você pode contar com um time completo de agentes:
 Integramos todos os fluxos de trabalho essenciais:
 - `/plan`, `/create`, `/debug`, `/test`, `/deploy`, `/enhance`, `/status`, `/orchestrate`, `/preview` e muito mais.
 
+---
+
+## 📜 Regras e Automação de Elite
+Agora incluímos a infraestrutura completa para transformar o assistente em um engenheiro de verdade:
+
+### 🛠️ Scripts de Automação (`.agent/scripts/`)
+Scripts prontos para serem executados pelos agentes:
+- **`checklist.py`**: Executor mestre de verificações (Segurança, Lint, Schema, UX, SEO).
+- **`verify_all.py`**: Suíte completa de validação pré-deploy.
+- **`session_manager.py`**: Analisador de contexto do projeto para o assistente.
+- **`auto_preview.py`**: Gestor de servidor de preview local.
+
+### ⚖️ Protocolos de Inteligência (`.agent/rules/`)
+Regras globais que guiam o comportamento da IA:
+- **`GEMINI.md`**: Define o protocolo "Agent & Skill", garantindo que a IA aplique as skills e use os agentes de forma sistemática e correta.
+
 ---
 - **Implementação**: Guias para React, Next.js, Vue e Tailwind.
 - **Acessibilidade**: Checklist rigoroso de conformidade WCAG.
@@ -350,6 +372,7 @@ Você pode acessar as skills diretamente via comandos de barra no chat:
 - `/marketing-campaigns`: Ativa o gestor de campanhas para planejamento e execução estratégica.
 - `/web-perf`: Ativa o engenheiro de performance para otimização de Core Web Vitals.
 - `/invoice-organizer`: Ativa o assistente de organização financeira e contábil.
+- `/figma`: Ativa a integração MCP com o Figma Dev Mode para extração visual.
 
 ## 📁 Estrutura do Projeto
 

package/index.js

@@ -16,7 +16,7 @@ const AGENTS_DIR = path.join(__dirname, '.agent', 'agents');
 program
   .name('myskills')
   .description('CLI para gerenciar e instalar skills e agents do Antigravity')
-  .version('1.0.14');
+  .version('1.0.19');
 
 program
   .command('list')
@@ -52,7 +52,7 @@ program
 
 program
   .command('init')
-  .description('Inicializa o Antigravity no projeto atual (instala todas as skills, agents e workflows)')
+  .description('Inicializa o Antigravity no projeto atual (instala todas as skills, agents, workflows, rules e scripts)')
   .action(async () => {
     const sourceDir = path.join(__dirname, '.agent');
     const destDir = path.join(process.cwd(), '.agent');
@@ -63,7 +63,7 @@ program
       await fs.ensureDir(destDir);
       await fs.copy(sourceDir, destDir);
       console.log(chalk.green.bold('✅ Pasta .agent instalada com sucesso!\n'));
-      console.log(chalk.gray('Isso inclui todas as skills, agents e slash commands (workflows).\n'));
+      console.log(chalk.gray('Isso inclui todas as skills, agents, workflows, rules e scripts de automação.\n'));
     } catch (err) {
       console.error(chalk.red(`\n❌ Erro ao inicializar .agent: ${err.message}\n`));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruyfranca/myskills",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "description": "Biblioteca de skills customizadas para Antigravity / Claude Code",
   "main": "index.js",
   "bin": {