everything-gemini 1.8.0 → 2.0.0

package/examples/python-sdk/platform_provisioning_pipeline.py

@@ -0,0 +1,193 @@
+#!/usr/bin/env python3
+"""
+Everything Gemini (everything-gemini) Python SDK Example
+Cloud Platform Provisioning & Zero-Trust Infrastructure Pipeline
+
+Orchestrates a 4-stage automated cloud delivery loop:
+Architect -> Platform Engineer -> Security Auditor -> Release Engineer
+"""
+
+import sys
+import json
+from dataclasses import dataclass, field
+from typing import List, Dict, Any, Optional
+
+@dataclass
+class PlatformWorkloadRequest:
+    workload_id: str
+    environment: str  # staging, production
+    cloud_provider: str  # gcp, aws, azure
+    cluster_region: str
+    expected_qps: int
+    data_retention_days: int
+    services: List[str] = field(default_factory=list)
+    compliance_frameworks: List[str] = field(default_factory=list)
+
+class PlatformProvisioningPipeline:
+    """Automates multi-agent cloud platform provisioning and compliance auditing."""
+
+    def __init__(self, request: PlatformWorkloadRequest):
+        self.request = request
+        self.audit_trail: List[Dict[str, Any]] = []
+        self.iac_manifests: Dict[str, str] = {}
+        self.security_clearance: bool = False
+        self.deployment_ready: bool = False
+
+    def log_event(self, agent: str, phase: str, status: str, details: str):
+        event = {
+            "agent": agent,
+            "phase": phase,
+            "status": status,
+            "details": details
+        }
+        self.audit_trail.append(event)
+        print(f"[{agent.upper()}] ({phase}): {status} - {details}")
+
+    def stage_1_architecture_blueprint(self) -> bool:
+        """Stage 1: Architect subagent designs high-availability topology and VPC segmentation."""
+        self.log_event(
+            agent="architect",
+            phase="topology_design",
+            status="DESIGNED",
+            details=f"Designed multi-zone VPC topology in {self.request.cluster_region} for {len(self.request.services)} services."
+        )
+
+        # Architectural scaling rules
+        if self.request.expected_qps > 5000:
+            topology = "multi-region-active-active"
+        else:
+            topology = "multi-zone-ha-regional"
+
+        self.log_event(
+            agent="architect",
+            phase="scaling_strategy",
+            status="CONFIRMED",
+            details=f"Selected topology: {topology} with horizontal pod autoscaling (HPA) target 75% CPU."
+        )
+        return True
+
+    def stage_2_platform_provisioning(self) -> bool:
+        """Stage 2: Platform Engineer generates Terraform/Helm modules and sizes compute resources."""
+        self.log_event(
+            agent="platform-engineer",
+            phase="iac_generation",
+            status="GENERATED",
+            details="Generated Terraform modules for GKE/EKS cluster, node pools, and VPC CNI."
+        )
+
+        # Resource right-sizing
+        cpu_request = "500m" if self.request.expected_qps < 1000 else "2000m"
+        ram_request = "1Gi" if self.request.expected_qps < 1000 else "4Gi"
+        
+        self.iac_manifests["helm_values"] = f"""
+replicaCount: 3
+resources:
+  requests:
+    cpu: {cpu_request}
+    memory: {ram_request}
+  limits:
+    cpu: {cpu_request}
+    memory: {ram_request}
+autoscaling:
+  enabled: true
+  minReplicas: 3
+  maxReplicas: 20
+  targetCPUUtilizationPercentage: 75
+"""
+        self.log_event(
+            agent="platform-engineer",
+            phase="resource_sizing",
+            status="OPTIMIZED",
+            details=f"Container resource requests sized to {cpu_request} CPU, {ram_request} RAM per pod."
+        )
+        return True
+
+    def stage_3_security_and_compliance_gate(self) -> bool:
+        """Stage 3: Security Auditor validates zero-trust network policies, RBAC, and Vault secrets."""
+        self.log_event(
+            agent="security-auditor",
+            phase="policy_scan",
+            status="INSPECTING",
+            details=f"Scanning against compliance standards: {', '.join(self.request.compliance_frameworks)}."
+        )
+
+        # Check for zero-trust network boundaries
+        has_ebpf_mtls = True
+        has_ephemeral_secrets = True
+
+        if has_ebpf_mtls and has_ephemeral_secrets:
+            self.security_clearance = True
+            self.log_event(
+                agent="security-auditor",
+                phase="zero_trust_verification",
+                status="APPROVED",
+                details="Zero-trust CiliumNetworkPolicy, Workload Identity, and Vault AppRole verified with zero findings."
+            )
+            return True
+        else:
+            self.log_event(
+                agent="security-auditor",
+                phase="zero_trust_verification",
+                status="REJECTED",
+                details="Missing automated mTLS or ephemeral secret rotation."
+            )
+            return False
+
+    def stage_4_release_and_canary_plan(self) -> bool:
+        """Stage 4: Release Engineer compiles progressive delivery plan and automated rollback triggers."""
+        if not self.security_clearance:
+            print("[RELEASE-ENGINEER] Blocked: Security clearance not granted.")
+            return False
+
+        self.log_event(
+            agent="release-engineer",
+            phase="canary_orchestration",
+            status="SCHEDULED",
+            details="Formulated 5% -> 25% -> 100% canary rollout with automated rollback on error rate > 0.5%."
+        )
+        self.deployment_ready = True
+        return True
+
+    def execute(self) -> Dict[str, Any]:
+        """Execute full platform delivery pipeline."""
+        print(f"\n🚀 Initiating Platform Provisioning Pipeline for '{self.request.workload_id}' ({self.request.environment})...\n")
+        
+        ok = self.stage_1_architecture_blueprint()
+        if ok:
+            ok = self.stage_2_platform_provisioning()
+        if ok:
+            ok = self.stage_3_security_and_compliance_gate()
+        if ok:
+            ok = self.stage_4_release_and_canary_plan()
+
+        report = {
+            "workload_id": self.request.workload_id,
+            "environment": self.request.environment,
+            "cloud_provider": self.request.cloud_provider,
+            "security_clearance": self.security_clearance,
+            "deployment_ready": self.deployment_ready,
+            "audit_trail_events": len(self.audit_trail),
+            "status": "APPROVED" if self.deployment_ready else "BLOCKED"
+        }
+        
+        print(f"\n✨ Platform Provisioning Pipeline Complete: Status = {report['status']}")
+        return report
+
+def main():
+    sample_request = PlatformWorkloadRequest(
+        workload_id="ai-vector-search-cluster",
+        environment="production",
+        cloud_provider="gcp",
+        cluster_region="us-central1",
+        expected_qps=8500,
+        data_retention_days=90,
+        services=["vector-ingestion", "milvus-cluster", "query-gateway"],
+        compliance_frameworks=["SOC2-Type2", "ISO-27001"]
+    )
+
+    pipeline = PlatformProvisioningPipeline(sample_request)
+    report = pipeline.execute()
+    print("\n" + json.dumps(report, indent=2))
+
+if __name__ == "__main__":
+    main()

package/mcp/README.md

@@ -55,6 +55,8 @@ Everything Gemini bundles ready-to-use blueprints in `mcp/mcp_config.example.jso
 | **`filesystem`** | `@modelcontextprotocol/server-filesystem` | Direct multi-directory filesystem inspection | Stdio |
 | **`sentry`** | `@modelcontextprotocol/server-sentry` | Real-time production error tracking, issue triage, and stacktrace analysis | Stdio |
 | **`slack`** | `@modelcontextprotocol/server-slack` | Automated incident channels, alert broadcasts, and team collaboration | Stdio |
+| **`puppeteer`** | `@modelcontextprotocol/server-puppeteer` | Headless browser automation, screenshot diffing, and dynamic web crawling | Stdio |
+| **`brave-search`** | `@modelcontextprotocol/server-brave-search` | Grounded live web search, documentation retrieval, and internet research | Stdio |
 
 ## Tool Auto-Discovery & Execution
 Once connected, tools declared by MCP servers are automatically injected into the agent's system prompt and executed through Antigravity's Language Server. Inspect active MCP servers in the Antigravity UI via **Additional Options (...) > MCP Servers**.

package/mcp/mcp_config.example.json

@@ -60,6 +60,17 @@
         "SLACK_BOT_TOKEN": "YOUR_SLACK_BOT_TOKEN",
         "SLACK_TEAM_ID": "YOUR_SLACK_TEAM_ID"
       }
+    },
+    "puppeteer": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-puppeteer"]
+    },
+    "brave-search": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
+      "env": {
+        "BRAVE_API_KEY": "YOUR_BRAVE_API_KEY"
+      }
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "everything-gemini",
-  "version": "1.8.0",
+  "version": "2.0.0",
   "description": "Everything Gemini (everything-gemini) - The Ultimate Agent Harness, Multi-Agent Orchestrator & Performance Suite for Gemini & Google Antigravity",
   "main": "bin/everything-gemini",
   "bin": {

package/scripts/validate.sh

@@ -149,7 +149,7 @@ if [ -f "$REPO_ROOT/tests/cli.test.js" ]; then
     echo "    ❌ ERROR: CLI test suite failed."
     ERRORS=$((ERRORS + 1))
   else
-    echo "    ✔ CLI test suite passed (26 assertions)"
+    echo "    ✔ CLI test suite passed (31 assertions)"
   fi
 fi
 

package/skills/chromadb-vector-store/SKILL.md

@@ -0,0 +1,188 @@
+---
+name: chromadb-vector-store
+description: Implements ChromaDB persistent vector storage, multi-modal embeddings, collection partitioning, metadata filtering, and semantic similarity search.
+---
+
+# ChromaDB Vector Store
+
+Provides production patterns for embedding generation, persistent collection management, metadata-filtered semantic retrieval, and hybrid search using ChromaDB.
+
+---
+
+## 1. Client Architecture
+
+ChromaDB operates in three deployment modes depending on scale and latency requirements:
+
+```
+  In-Process Ephemeral            Local Persistent                Client / Server
+┌──────────────────────┐     ┌───────────────────────┐     ┌────────────────────────┐
+│ chromadb.Client()    │     │ PersistentClient(path)│     │ HttpClient(host, port) │
+│ (Unit Tests & CI)    │     │ (Embedded SQLite/HNSW)│     │ (Kubernetes / Docker)  │
+└──────────────────────┘     └───────────────────────┘     └────────────────────────┘
+```
+
+```python
+import chromadb
+from chromadb.config import Settings
+
+# Production persistent client with DuckDB + HNSW backend
+client = chromadb.PersistentClient(
+    path="./data/chroma",
+    settings=Settings(
+        anonymized_telemetry=False,
+        allow_reset=False,
+    )
+)
+```
+
+---
+
+## 2. Gemini Embeddings & Collection Creation
+
+Integrates native Gemini embeddings (`text-embedding-004`) with custom collection metrics:
+
+```python
+import chromadb
+from chromadb.api.types import Documents, EmbeddingFunction, Embeddings
+from google import genai
+
+class GeminiEmbeddingFunction(EmbeddingFunction):
+    def __init__(self, model_name: str = "text-embedding-004"):
+        self.client = genai.Client()
+        self.model_name = model_name
+
+    def __call__(self, input: Documents) -> Embeddings:
+        response = self.client.models.embed_content(
+            model=self.model_name,
+            contents=input,
+        )
+        return [e.values for e in response.embeddings]
+
+gemini_ef = GeminiEmbeddingFunction()
+
+# Create or get collection with Cosine distance metric
+collection = client.get_or_create_collection(
+    name="technical_runbooks_v2",
+    embedding_function=gemini_ef,
+    metadata={"hnsw:space": "cosine", "description": "Antigravity skills catalog"}
+)
+```
+
+---
+
+## 3. High-Throughput Batch Upsert
+
+Batch insertion ensures zero duplicate embeddings and enforces metadata schemas:
+
+```python
+from typing import List, Dict, Any
+
+def upsert_knowledge_batch(
+    collection,
+    doc_ids: List[str],
+    texts: List[str],
+    metadatas: List[Dict[str, Any]]
+):
+    """Upserts documents in batches of 500 to stay within gRPC frame limits."""
+    batch_size = 500
+    for i in range(0, len(doc_ids), batch_size):
+        chunk_ids = doc_ids[i:i + batch_size]
+        chunk_texts = texts[i:i + batch_size]
+        chunk_metas = metadatas[i:i + batch_size]
+
+        collection.upsert(
+            ids=chunk_ids,
+            documents=chunk_texts,
+            metadatas=chunk_metas
+        )
+```
+
+---
+
+## 4. Metadata Filtering & Semantic Search
+
+Queries can filter across Boolean operators (`$and`, `$or`), numerical ranges, and substring matching:
+
+```python
+results = collection.query(
+    query_texts=["How do I configure KEDA ScaledObjects for Kafka?"],
+    n_results=5,
+    where={
+        "$and": [
+            {"category": {"$eq": "devops"}},
+            {"security_tier": {"$lte": 2}},
+            {"status": {"$ne": "deprecated"}}
+        ]
+    },
+    where_document={"$contains": "ScaledObject"},
+    include=["documents", "metadatas", "distances"]
+)
+
+# Parse matched documents
+for idx, (doc, meta, dist) in enumerate(zip(
+    results["documents"][0],
+    results["metadatas"][0],
+    results["distances"][0]
+)):
+    similarity_score = 1.0 - dist
+    print(f"[{idx+1}] Score: {similarity_score:.4f} | ID: {results['ids'][0][idx]}")
+    print(f"     Title: {meta.get('title')} (v{meta.get('version')})")
+```
+
+---
+
+## 5. Dockerized Server Deployment
+
+For multi-tenant or distributed Antigravity agents:
+
+```yaml
+# compose.chroma.yml
+version: "3.9"
+services:
+  chromadb:
+    image: chromadb/chroma:0.5.23
+    ports:
+      - "8000:8000"
+    environment:
+      - IS_PERSISTENT=TRUE
+      - PERSISTENCE_DIRECTORY=/chroma/chroma
+      - ANONYMIZED_TELEMETRY=FALSE
+    volumes:
+      - chroma_data:/chroma/chroma
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8000/api/v1/heartbeat"]
+      interval: 10s
+      timeout: 5s
+      retries: 3
+
+volumes:
+  chroma_data:
+```
+
+```python
+# Connect via HTTP
+remote_client = chromadb.HttpClient(
+    host="localhost",
+    port=8000,
+    headers={"X-Chroma-Token": "secret-auth-token"}
+)
+```
+
+---
+
+## 6. Verification and Maintenance
+
+```bash
+# Verify Chroma API heartbeat
+curl -s http://localhost:8000/api/v1/heartbeat | jq .
+
+# Check active collections count and schema
+curl -s http://localhost:8000/api/v1/collections | jq '.[].name'
+
+# Reset collection or clean expired embeddings safely
+python -c "
+import chromadb
+client = chromadb.PersistentClient('./data/chroma')
+print(f'Collections: {len(client.list_collections())}')
+"
+```

package/skills/cloudflare-r2-object-storage/SKILL.md

@@ -0,0 +1,143 @@
+---
+name: cloudflare-r2-object-storage
+description: >-
+  Architects, configures, and integrates Cloudflare R2 zero-egress object storage using S3-compatible APIs, pre-signed upload URLs, multipart streaming, and edge CDN distribution.
+---
+
+# Cloudflare R2 Object Storage & Edge Distribution
+
+This skill guides the implementation of zero-egress fee object storage using Cloudflare R2 with S3-compatible APIs, pre-signed URLs, multipart uploads, and edge CDN distribution.
+
+---
+
+## ⚡ Architectural Comparison: R2 vs Standard S3
+
+| Feature | Cloudflare R2 | Standard AWS S3 |
+| :--- | :--- | :--- |
+| **Data Egress Fees** | **$0.00 / GB (Free)** | ~$0.09 / GB |
+| **API Compatibility** | Full S3 API v4 signature | Native AWS S3 |
+| **Edge Integration** | Native Cloudflare Workers & CDN | CloudFront integration required |
+| **Storage Pricing** | $0.015 / GB-month | $0.023 / GB-month |
+| **Global Replication** | Automatic across edge locations | Cross-Region Replication (CRR) billed |
+
+---
+
+## 🛠️ TypeScript S3 Client Configuration (`@aws-sdk/client-s3`)
+
+R2 endpoints use account-specific URLs with AWS Signature Version 4:
+
+```typescript
+import { S3Client, PutObjectCommand, GetObjectCommand } from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+
+const ACCOUNT_ID = process.env.CLOUDFLARE_ACCOUNT_ID!;
+const R2_ACCESS_KEY_ID = process.env.R2_ACCESS_KEY_ID!;
+const R2_SECRET_ACCESS_KEY = process.env.R2_SECRET_ACCESS_KEY!;
+
+export const r2Client = new S3Client({
+  region: 'auto',
+  endpoint: `https://${ACCOUNT_ID}.r2.cloudflarestorage.com`,
+  credentials: {
+    accessKeyId: R2_ACCESS_KEY_ID,
+    secretAccessKey: R2_SECRET_ACCESS_KEY,
+  },
+});
+```
+
+---
+
+## 📤 Pre-Signed URLs for Direct Browser Uploads
+
+Prevent API server bottlenecking by generating short-lived pre-signed upload URLs:
+
+```typescript
+export async function generateUploadUrl(key: string, contentType: string, expiresInSeconds = 300) {
+  const command = new PutObjectCommand({
+    Bucket: 'enterprise-artifacts',
+    Key: key,
+    ContentType: contentType,
+  });
+
+  const uploadUrl = await getSignedUrl(r2Client, command, { expiresIn: expiresInSeconds });
+  return {
+    uploadUrl,
+    key,
+    publicUrl: `https://cdn.example.com/${key}`,
+  };
+}
+```
+
+---
+
+## 📦 High-Throughput Multipart Uploads (Node.js / Python)
+
+For files exceeding 100MB, use parallel multipart uploads with the Upload helper:
+
+```typescript
+import { Upload } from '@aws-sdk/lib-storage';
+import fs from 'node:fs';
+
+export async function uploadLargeArchive(filePath: string, destinationKey: string) {
+  const fileStream = fs.createReadStream(filePath);
+  
+  const parallelUpload = new Upload({
+    client: r2Client,
+    params: {
+      Bucket: 'enterprise-artifacts',
+      Key: destinationKey,
+      Body: fileStream,
+      ContentType: 'application/octet-stream',
+    },
+    queueSize: 4,          // 4 concurrent part uploads
+    partSize: 10 * 1024 * 1024, // 10MB chunk size
+    leavePartsOnError: false,
+  });
+
+  parallelUpload.on('httpUploadProgress', (progress) => {
+    console.log(`Uploaded ${progress.loaded} of ${progress.total} bytes`);
+  });
+
+  return await parallelUpload.done();
+}
+```
+
+---
+
+## 🌐 Custom Domain & Cloudflare CDN Caching Rule
+
+Expose R2 buckets through a custom domain with edge cache headers:
+
+```javascript
+// Cloudflare Worker Edge Proxy
+export default {
+  async fetch(request, env) {
+    const url = new URL(request.url);
+    const key = url.pathname.slice(1);
+
+    if (request.method !== 'GET') {
+      return new Response('Method Not Allowed', { status: 405 });
+    }
+
+    const object = await env.MY_R2_BUCKET.get(key);
+    if (!object) {
+      return new Response('Not Found', { status: 404 });
+    }
+
+    const headers = new Headers();
+    object.writeHttpMetadata(headers);
+    headers.set('etag', object.httpEtag);
+    headers.set('Cache-Control', 'public, max-age=31536000, immutable');
+
+    return new Response(object.body, { headers });
+  },
+};
+```
+
+---
+
+## 📋 Architectural Rules & Best Practices
+
+1. **Bucket Region**: Always set region to `auto` in AWS S3 SDK clients; R2 automatically routes storage to the lowest-latency regional cluster.
+2. **CORS Headers**: Set permissive CORS rules (`AllowedOrigins`, `AllowedMethods: ["PUT", "GET"]`) on the R2 bucket for direct browser pre-signed uploads.
+3. **Multipart Cleanup**: Configure bucket lifecycle rules to automatically abort incomplete multipart uploads after 7 days (`AbortIncompleteMultipartUpload`).
+4. **Zero-Egress Strategy**: Route public media and file downloads through Cloudflare Custom Domains or Workers to benefit from zero bandwidth charges.