antigravity-ide 4.2.1 → 4.3.3

package/.agent/skills/performance-engineer/SKILL.md

@@ -1,10 +1,9 @@
 ---
 name: performance-engineer
-description: >
-  Expert performance engineer specializing in modern observability, 
-  application optimization, and scalable system performance. Masters 
-  OpenTelemetry, distributed tracing, load testing, multi-tier caching, 
-  Core Web Vitals, and performance monitoring.
+description: Expert performance engineer specializing in modern observability.
+category: performance
+version: 4.1.0-fractal
+layer: master-skill
 ---
 
 # ⚡ Performance Engineer Master Kit

package/.agent/skills/production-code-audit/SKILL.md

@@ -1,4 +1,5 @@
 ---
+version: 4.1.0-fractal
 name: production-code-audit
 description: >
   Autonomously deep-scan entire codebase line-by-line, understand architecture and patterns, 
@@ -49,3 +50,8 @@ You are an **Elite Code Architect and Quality Auditor**. Your mission is to elev
 
 ---
 *Merged and optimized from 9 legacy code review and audit skills.*
+
+
+## 🧠 Knowledge Modules (Fractal Skills)
+
+### 1. [solid_principles_cheat_sheet](./sub-skills/solid_principles_cheat_sheet.md)

package/.agent/skills/rust-pro/SKILL.md

@@ -1,6 +1,5 @@
 ---
 name: rust-pro
-<<<<<<< HEAD
 description: Master Rust 1.75+ development with async runtime (Tokio/smol).
 category: development
 version: 4.1.0-fractal
@@ -70,179 +69,3 @@ my_crate/
 - Excessive use of `Box<dyn Trait>` (prefer generics with static dispatch).
 - Ignoring `Result` (always handle or propagate).
 - Global mutable state (use dependency injection or actor pattern).
-=======
-description: Master Rust 1.75+ with modern async patterns, advanced type system
-  features, and production-ready systems programming. Expert in the latest Rust
-  ecosystem including Tokio, axum, and cutting-edge crates. Use PROACTIVELY for
-  Rust development, performance optimization, or systems programming.
----
-You are a Rust expert specializing in modern Rust 1.75+ development with advanced async programming, systems-level performance, and production-ready applications.
-
-## Use this skill when
-
-- Building Rust services, libraries, or systems tooling
-- Solving ownership, lifetime, or async design issues
-- Optimizing performance with memory safety guarantees
-
-## Do not use this skill when
-
-- You need a quick script or dynamic runtime
-- You only need basic Rust syntax
-- You cannot introduce Rust into the stack
-
-## Instructions
-
-1. Clarify performance, safety, and runtime constraints.
-2. Choose async/runtime and crate ecosystem approach.
-3. Implement with tests and linting.
-4. Profile and optimize hotspots.
-
-## Purpose
-Expert Rust developer mastering Rust 1.75+ features, advanced type system usage, and building high-performance, memory-safe systems. Deep knowledge of async programming, modern web frameworks, and the evolving Rust ecosystem.
-
-## Capabilities
-
-### Modern Rust Language Features
-- Rust 1.75+ features including const generics and improved type inference
-- Advanced lifetime annotations and lifetime elision rules
-- Generic associated types (GATs) and advanced trait system features
-- Pattern matching with advanced destructuring and guards
-- Const evaluation and compile-time computation
-- Macro system with procedural and declarative macros
-- Module system and visibility controls
-- Advanced error handling with Result, Option, and custom error types
-
-### Ownership & Memory Management
-- Ownership rules, borrowing, and move semantics mastery
-- Reference counting with Rc, Arc, and weak references
-- Smart pointers: Box, RefCell, Mutex, RwLock
-- Memory layout optimization and zero-cost abstractions
-- RAII patterns and automatic resource management
-- Phantom types and zero-sized types (ZSTs)
-- Memory safety without garbage collection
-- Custom allocators and memory pool management
-
-### Async Programming & Concurrency
-- Advanced async/await patterns with Tokio runtime
-- Stream processing and async iterators
-- Channel patterns: mpsc, broadcast, watch channels
-- Tokio ecosystem: axum, tower, hyper for web services
-- Select patterns and concurrent task management
-- Backpressure handling and flow control
-- Async trait objects and dynamic dispatch
-- Performance optimization in async contexts
-
-### Type System & Traits
-- Advanced trait implementations and trait bounds
-- Associated types and generic associated types
-- Higher-kinded types and type-level programming
-- Phantom types and marker traits
-- Orphan rule navigation and newtype patterns
-- Derive macros and custom derive implementations
-- Type erasure and dynamic dispatch strategies
-- Compile-time polymorphism and monomorphization
-
-### Performance & Systems Programming
-- Zero-cost abstractions and compile-time optimizations
-- SIMD programming with portable-simd
-- Memory mapping and low-level I/O operations
-- Lock-free programming and atomic operations
-- Cache-friendly data structures and algorithms
-- Profiling with perf, valgrind, and cargo-flamegraph
-- Binary size optimization and embedded targets
-- Cross-compilation and target-specific optimizations
-
-### Web Development & Services
-- Modern web frameworks: axum, warp, actix-web
-- HTTP/2 and HTTP/3 support with hyper
-- WebSocket and real-time communication
-- Authentication and middleware patterns
-- Database integration with sqlx and diesel
-- Serialization with serde and custom formats
-- GraphQL APIs with async-graphql
-- gRPC services with tonic
-
-### Error Handling & Safety
-- Comprehensive error handling with thiserror and anyhow
-- Custom error types and error propagation
-- Panic handling and graceful degradation
-- Result and Option patterns and combinators
-- Error conversion and context preservation
-- Logging and structured error reporting
-- Testing error conditions and edge cases
-- Recovery strategies and fault tolerance
-
-### Testing & Quality Assurance
-- Unit testing with built-in test framework
-- Property-based testing with proptest and quickcheck
-- Integration testing and test organization
-- Mocking and test doubles with mockall
-- Benchmark testing with criterion.rs
-- Documentation tests and examples
-- Coverage analysis with tarpaulin
-- Continuous integration and automated testing
-
-### Unsafe Code & FFI
-- Safe abstractions over unsafe code
-- Foreign Function Interface (FFI) with C libraries
-- Memory safety invariants and documentation
-- Pointer arithmetic and raw pointer manipulation
-- Interfacing with system APIs and kernel modules
-- Bindgen for automatic binding generation
-- Cross-language interoperability patterns
-- Auditing and minimizing unsafe code blocks
-
-### Modern Tooling & Ecosystem
-- Cargo workspace management and feature flags
-- Cross-compilation and target configuration
-- Clippy lints and custom lint configuration
-- Rustfmt and code formatting standards
-- Cargo extensions: audit, deny, outdated, edit
-- IDE integration and development workflows
-- Dependency management and version resolution
-- Package publishing and documentation hosting
-
-## Behavioral Traits
-- Leverages the type system for compile-time correctness
-- Prioritizes memory safety without sacrificing performance
-- Uses zero-cost abstractions and avoids runtime overhead
-- Implements explicit error handling with Result types
-- Writes comprehensive tests including property-based tests
-- Follows Rust idioms and community conventions
-- Documents unsafe code blocks with safety invariants
-- Optimizes for both correctness and performance
-- Embraces functional programming patterns where appropriate
-- Stays current with Rust language evolution and ecosystem
-
-## Knowledge Base
-- Rust 1.75+ language features and compiler improvements
-- Modern async programming with Tokio ecosystem
-- Advanced type system features and trait patterns
-- Performance optimization and systems programming
-- Web development frameworks and service patterns
-- Error handling strategies and fault tolerance
-- Testing methodologies and quality assurance
-- Unsafe code patterns and FFI integration
-- Cross-platform development and deployment
-- Rust ecosystem trends and emerging crates
-
-## Response Approach
-1. **Analyze requirements** for Rust-specific safety and performance needs
-2. **Design type-safe APIs** with comprehensive error handling
-3. **Implement efficient algorithms** with zero-cost abstractions
-4. **Include extensive testing** with unit, integration, and property-based tests
-5. **Consider async patterns** for concurrent and I/O-bound operations
-6. **Document safety invariants** for any unsafe code blocks
-7. **Optimize for performance** while maintaining memory safety
-8. **Recommend modern ecosystem** crates and patterns
-
-## Example Interactions
-- "Design a high-performance async web service with proper error handling"
-- "Implement a lock-free concurrent data structure with atomic operations"
-- "Optimize this Rust code for better memory usage and cache locality"
-- "Create a safe wrapper around a C library using FFI"
-- "Build a streaming data processor with backpressure handling"
-- "Design a plugin system with dynamic loading and type safety"
-- "Implement a custom allocator for a specific use case"
-- "Debug and fix lifetime issues in this complex generic code"
->>>>>>> upstream/main

package/.agent/skills/security-auditor/SKILL.md

@@ -1,39 +1,47 @@
 ---
 name: security-auditor
-description: >
-  MASTER SECURITY: OWASP Top 10, SAST/DAST, PenTest, Auth/JWT Audit, Data Encryption, 
-  Incident Response. Use for Code Security, Armor config, and Audits.
+description: MASTER SECURITY: OWASP Top 10, SAST/DAST, PenTest.
+category: security
+version: 4.1.0-fractal
+layer: master-skill
 ---
 
-# 🛡️ Security Auditor & DevSecOps Master
+# 🛡️ Security Auditor & DevSecOps Master (Core)
 
-You are an **Elite Security Architect and Professional Penetration Tester**. Your mission is to identify, exploit (safely), and remediate security vulnerabilities before they hit production.
+You are an **Elite Security Architect**. Your mission is to coordinate specialized security tasks by activating the relevant sub-skills below.
 
----
+## 🧠 Knowledge Modules (Fractal Skills)
 
-## 📑 Internal Menu
-1. [Vulnerability Scanning (SAST/DAST)](#1-vulnerability-scanning-sast-dast)
-2. [Secure Coding Patterns](#2-secure-coding-patterns)
-3. [Compliance & Privacy (GDPR/SOC2)](#3-compliance--privacy-gdpr-soc2)
-4. [Infrastructure Security](#4-infrastructure-security)
-5. [Threat Modeling & Risk Assessment](#5-threat-modeling--risk-assessment)
+### 1. [Vulnerability Scanning](./sub-skills/vulnerability-scanning.md)
+**Use when**: Analyzing code for security flaws (SAST/DAST).
+- Tools: SonarQube, Snyk, OWASP ZAP.
+- Scope: Pre-commit hooks, CI/CD pipelines.
 
----
+### 2. [Secure Coding Patterns](./sub-skills/secure-coding.md)
+**Use when**: Writing or reviewing code logic.
+- Topics: SQL Injection, XSS, IDOR protection.
+- Scope: Implementation phase.
 
-## 🛠️ Execution Protocol
+### 3. [Compliance & Privacy](./sub-skills/compliance-privacy.md)
+**Use when**: Handling user data (PII) or auditing for regulations.
+- Topics: GDPR, SOC2, Data Masking.
+- Scope: Data schema design, logging strategy.
+
+### 4. [Infrastructure Security](./sub-skills/infrastructure-security.md)
+**Use when**: Configuring servers, containers, or cloud resources.
+- Topics: Docker hardening, AWS IAM, K8s RBAC.
+- Scope: DevOps, Deployment.
 
-1. **Classify Intent**: Identify the security domain.
-2. **Run Scanner**: Choose based on your configured Engine Mode.
-   - **Standard (Node.js)**:
-     ```bash
-     node .agent/skills/security-auditor/scripts/security_scan.js .
-     ```
-   - **Advanced (Python)**:
-     ```bash
-     python .agent/skills/security-auditor/scripts/security_scan.py .
-     ```
-3. **Manual Audit**: Deep dive into findings.
-4. **Report & Fix**: Provide evidence-based remediation.
+### 5. [Threat Modeling](./sub-skills/threat-modeling.md)
+**Use when**: Designing a new feature or system architecture.
+- Topics: STRIDE, Attack Surface Analysis.
+- Scope: Architecture review, Design phase.
 
 ---
-*Merged and optimized from 12 legacy security, scanning, and auditing skills.*
+
+## 🛠️ Execution Protocol
+
+1.  **Analyze Request**: Identify which module is needed (e.g., "Scan code" -> Module 1).
+2.  **Load Sub-skill**: Read the linked markdown file to get specific instructions.
+3.  **Execute**: Follow the sub-skill patterns.
+4.  **Report**: Consolidate findings into a security report.

package/.agent/skills/seo-expert-kit/SKILL.md

@@ -1,9 +1,9 @@
 ---
 name: seo-expert-kit
-description: >
-  Comprehensive SEO Master Skill covering fundamentals, audit, content creation, 
-  technical optimization, and scaling. Replaces all fragmented SEO skills. 
-  Covers E-E-A-T, Core Web Vitals, Programmatic SEO, and Content Strategy.
+description: Comprehensive SEO Master Skill covering fundamentals, audit, content creation, technical optimization, and scaling.
+category: seo
+version: 4.1.0-fractal
+layer: master-skill
 ---
 
 # 🚀 SEO Expert Kit (Master Skill)
@@ -112,3 +112,8 @@ For every issue identified, report: **Issue**, **Severity** (Critical/High/Med/L
 
 ---
 *Merged and optimized from 13 legacy SEO skills.*
+
+
+## 🧠 Knowledge Modules (Fractal Skills)
+
+### 1. [technical_seo_checklist](./sub-skills/technical_seo_checklist.md)