@musashishao/agent-kit 1.8.1 → 1.9.0

package/.agent/skills/game-development/webgpu-shading/SKILL.md

@@ -0,0 +1,209 @@
+---
+name: webgpu-shading
+description: WebGPU and shader programming for web games. Covers WGSL, Three.js WebGPU, Babylon.js, and shader optimization.
+allowed-tools: Read, Write, Edit, Bash, Grep, WebSearch
+---
+
+# WebGPU & Shading Skill
+
+> Next-generation web graphics with WebGPU and WGSL.
+
+## When to Use
+
+- Developing 3D web games with modern graphics
+- Writing custom shaders (WGSL, GLSL)
+- Optimizing rendering performance
+- Using Three.js or Babylon.js with WebGPU
+
+---
+
+## WebGPU Browser Support (2025)
+
+| Browser | Status |
+|---------|--------|
+| Chrome 113+ | ✅ Stable |
+| Edge 113+ | ✅ Stable |
+| Firefox 131+ | ✅ Stable |
+| Safari 18+ | ✅ Stable |
+| **Total Coverage** | ~78% |
+
+---
+
+## WebGPU vs WebGL
+
+| Feature | WebGL | WebGPU |
+|---------|-------|--------|
+| API Style | Immediate | Command-based |
+| Compute Shaders | No | Yes |
+| Multi-threading | Limited | Full |
+| Memory Control | Low | High |
+| Performance | Good | Better |
+
+---
+
+## Basic WebGPU Setup
+
+```javascript
+async function initWebGPU() {
+    if (!navigator.gpu) {
+        throw new Error("WebGPU not supported");
+    }
+    
+    const adapter = await navigator.gpu.requestAdapter();
+    const device = await adapter.requestDevice();
+    
+    const canvas = document.getElementById("canvas");
+    const context = canvas.getContext("webgpu");
+    
+    context.configure({
+        device,
+        format: navigator.gpu.getPreferredCanvasFormat(),
+        alphaMode: "premultiplied"
+    });
+    
+    return { device, context };
+}
+```
+
+---
+
+## WGSL Shader Basics
+
+### Vertex Shader
+
+```wgsl
+struct VertexInput {
+    @location(0) position: vec3f,
+    @location(1) uv: vec2f,
+}
+
+struct VertexOutput {
+    @builtin(position) position: vec4f,
+    @location(0) uv: vec2f,
+}
+
+@group(0) @binding(0) var<uniform> mvp: mat4x4f;
+
+@vertex
+fn main(input: VertexInput) -> VertexOutput {
+    var output: VertexOutput;
+    output.position = mvp * vec4f(input.position, 1.0);
+    output.uv = input.uv;
+    return output;
+}
+```
+
+### Fragment Shader
+
+```wgsl
+@group(0) @binding(1) var textureSampler: sampler;
+@group(0) @binding(2) var texture: texture_2d<f32>;
+
+@fragment
+fn main(@location(0) uv: vec2f) -> @location(0) vec4f {
+    return textureSample(texture, textureSampler, uv);
+}
+```
+
+---
+
+## Three.js WebGPU
+
+```javascript
+import * as THREE from 'three/webgpu';
+import { MeshStandardNodeMaterial } from 'three/nodes';
+
+async function createScene() {
+    const renderer = new THREE.WebGPURenderer();
+    await renderer.init();
+    
+    renderer.setSize(window.innerWidth, window.innerHeight);
+    document.body.appendChild(renderer.domElement);
+    
+    const scene = new THREE.Scene();
+    const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight);
+    camera.position.z = 5;
+    
+    // Node-based material for WebGPU
+    const material = new MeshStandardNodeMaterial({
+        color: 0x00ff00,
+        roughness: 0.5,
+        metalness: 0.5
+    });
+    
+    const geometry = new THREE.BoxGeometry();
+    const mesh = new THREE.Mesh(geometry, material);
+    scene.add(mesh);
+    
+    function animate() {
+        mesh.rotation.x += 0.01;
+        mesh.rotation.y += 0.01;
+        renderer.render(scene, camera);
+    }
+    
+    renderer.setAnimationLoop(animate);
+}
+```
+
+---
+
+## Common Shader Effects
+
+### Screen Flash
+
+```wgsl
+@group(0) @binding(0) var<uniform> flashAmount: f32;
+@group(0) @binding(1) var<uniform> flashColor: vec3f;
+
+@fragment
+fn main(@location(0) uv: vec2f) -> @location(0) vec4f {
+    let texColor = textureSample(texture, sampler, uv);
+    return mix(texColor, vec4f(flashColor, 1.0), flashAmount);
+}
+```
+
+### Outline Effect
+
+```wgsl
+fn outline(uv: vec2f, size: f32) -> f32 {
+    let offsets = array<vec2f, 4>(
+        vec2f(size, 0.0),
+        vec2f(-size, 0.0),
+        vec2f(0.0, size),
+        vec2f(0.0, -size)
+    );
+    
+    var alpha = 0.0;
+    for (var i = 0; i < 4; i++) {
+        alpha += textureSample(texture, sampler, uv + offsets[i]).a;
+    }
+    return alpha;
+}
+```
+
+---
+
+## Performance Tips
+
+| Tip | Impact |
+|-----|--------|
+| Batch draw calls | High |
+| Use instancing | High |
+| Minimize state changes | Medium |
+| Compress textures (KTX2) | Medium |
+| Use LOD for meshes | Medium |
+| Avoid branching in shaders | Low |
+
+---
+
+## Anti-Patterns
+
+| ❌ Don't | ✅ Do |
+|----------|-------|
+| Load uncompressed textures | Use Basis Universal/KTX2 |
+| Draw call per object | Batch/Instance |
+| Dynamic uniforms per frame | Uniform buffer objects |
+| Complex branching in shader | Precompute |
+| Skip feature detection | Test `navigator.gpu` |
+
+> **Remember:** WebGPU is the future of web graphics. Design for it, with WebGL fallback.

package/.agent/skills/gcp-cloud-run/SKILL.md

@@ -0,0 +1,358 @@
+---
+name: gcp-cloud-run
+description: "Google Cloud Run and Cloud Functions patterns. Covers containerized deployments, Cloud Functions Gen2, Firestore, Pub/Sub, and Terraform/Pulumi IaC."
+version: "1.0.0"
+---
+
+# ☁️ GCP Cloud Run
+
+You are a Google Cloud expert who has deployed production applications on Cloud Run and Cloud Functions. You understand the container-based model, scaling behavior, and GCP service integrations.
+
+---
+
+## When to Use This Skill
+
+- Deploying containerized apps with Cloud Run
+- Event-driven processing with Cloud Functions Gen2
+- Firestore/Bigtable data modeling
+- Pub/Sub message queues
+- Cloud Build CI/CD pipelines
+
+---
+
+## Capabilities
+
+- `cloud-run`
+- `cloud-functions`
+- `firestore`
+- `pub-sub`
+- `cloud-build`
+- `artifact-registry`
+- `cloud-tasks`
+- `cloud-scheduler`
+
+---
+
+## 1. Cloud Run Patterns
+
+### Dockerfile for Cloud Run
+
+```dockerfile
+# Dockerfile
+FROM node:20-slim AS builder
+
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --only=production
+
+COPY . .
+RUN npm run build
+
+# Production image
+FROM node:20-slim
+
+ENV NODE_ENV=production
+WORKDIR /app
+
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/node_modules ./node_modules
+COPY package*.json ./
+
+# Cloud Run uses PORT env var
+EXPOSE 8080
+CMD ["node", "dist/server.js"]
+```
+
+### Node.js Server
+
+```javascript
+// server.js
+const express = require('express');
+const { Firestore } = require('@google-cloud/firestore');
+
+const app = express();
+app.use(express.json());
+
+// Initialize outside request handler
+const firestore = new Firestore();
+const collection = firestore.collection('users');
+
+app.get('/users/:id', async (req, res) => {
+  try {
+    const doc = await collection.doc(req.params.id).get();
+    
+    if (!doc.exists) {
+      return res.status(404).json({ error: 'User not found' });
+    }
+    
+    res.json({ id: doc.id, ...doc.data() });
+  } catch (error) {
+    console.error('Error:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+app.post('/users', async (req, res) => {
+  try {
+    const docRef = await collection.add(req.body);
+    res.status(201).json({ id: docRef.id });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// Cloud Run provides PORT
+const PORT = process.env.PORT || 8080;
+app.listen(PORT, () => {
+  console.log(`Server running on port ${PORT}`);
+});
+```
+
+### Deploy Command
+
+```bash
+# Build and push
+gcloud builds submit --tag gcr.io/$PROJECT_ID/my-service
+
+# Deploy
+gcloud run deploy my-service \
+  --image gcr.io/$PROJECT_ID/my-service \
+  --platform managed \
+  --region us-central1 \
+  --allow-unauthenticated \
+  --min-instances 1 \
+  --max-instances 100 \
+  --memory 512Mi \
+  --cpu 1 \
+  --set-env-vars "NODE_ENV=production"
+```
+
+---
+
+## 2. Cloud Functions Gen2 Pattern
+
+```javascript
+// index.js
+const functions = require('@google-cloud/functions-framework');
+const { Firestore } = require('@google-cloud/firestore');
+
+const firestore = new Firestore();
+
+// HTTP function
+functions.http('helloHttp', async (req, res) => {
+  const name = req.query.name || req.body.name || 'World';
+  res.json({ message: `Hello, ${name}!` });
+});
+
+// Cloud Event function (Pub/Sub)
+functions.cloudEvent('helloPubSub', async (cloudEvent) => {
+  const message = Buffer.from(cloudEvent.data.message.data, 'base64').toString();
+  console.log(`Received message: ${message}`);
+  
+  // Process message
+  await firestore.collection('messages').add({
+    content: message,
+    timestamp: new Date()
+  });
+});
+
+// Firestore trigger
+functions.cloudEvent('onUserCreate', async (event) => {
+  const document = event.data;
+  console.log('New user created:', document);
+  
+  // Send welcome email
+  await sendWelcomeEmail(document.email);
+});
+```
+
+### Deploy Cloud Function
+
+```bash
+gcloud functions deploy my-function \
+  --gen2 \
+  --runtime nodejs20 \
+  --trigger-http \
+  --allow-unauthenticated \
+  --region us-central1 \
+  --entry-point helloHttp
+```
+
+---
+
+## 3. Pub/Sub Pattern
+
+### Publisher
+
+```javascript
+const { PubSub } = require('@google-cloud/pubsub');
+const pubsub = new PubSub();
+
+async function publishMessage(topicName, data) {
+  const topic = pubsub.topic(topicName);
+  
+  const messageBuffer = Buffer.from(JSON.stringify(data));
+  
+  const messageId = await topic.publish(messageBuffer, {
+    // Ordering key for ordered delivery
+    orderingKey: data.userId
+  });
+  
+  console.log(`Message ${messageId} published.`);
+  return messageId;
+}
+```
+
+### Subscriber (Push to Cloud Run)
+
+```javascript
+// Pub/Sub push endpoint in Cloud Run
+app.post('/pubsub/push', async (req, res) => {
+  try {
+    // Verify Pub/Sub token if configured
+    const token = req.query.token;
+    if (token !== process.env.PUBSUB_VERIFICATION_TOKEN) {
+      return res.status(403).send('Forbidden');
+    }
+    
+    const message = JSON.parse(
+      Buffer.from(req.body.message.data, 'base64').toString()
+    );
+    
+    await processMessage(message);
+    
+    // Acknowledge by returning 2xx
+    res.status(200).send('OK');
+  } catch (error) {
+    console.error('Error processing message:', error);
+    // Return 5xx to retry
+    res.status(500).send('Error');
+  }
+});
+```
+
+---
+
+## 4. Firestore Patterns
+
+### Single Document Pattern
+
+```javascript
+// Get with caching
+async function getUser(userId) {
+  const cacheKey = `user:${userId}`;
+  
+  // Check cache
+  const cached = await cache.get(cacheKey);
+  if (cached) return cached;
+  
+  // Fetch from Firestore
+  const doc = await firestore.collection('users').doc(userId).get();
+  
+  if (!doc.exists) return null;
+  
+  const user = { id: doc.id, ...doc.data() };
+  
+  // Cache for 5 minutes
+  await cache.set(cacheKey, user, 300);
+  
+  return user;
+}
+```
+
+### Batch Operations
+
+```javascript
+// Batch write for better performance
+async function createUsers(users) {
+  const batch = firestore.batch();
+  
+  users.forEach(user => {
+    const ref = firestore.collection('users').doc();
+    batch.set(ref, {
+      ...user,
+      createdAt: Firestore.FieldValue.serverTimestamp()
+    });
+  });
+  
+  await batch.commit();
+}
+```
+
+---
+
+## 5. Cloud Build CI/CD
+
+```yaml
+# cloudbuild.yaml
+steps:
+  # Run tests
+  - name: 'node:20'
+    entrypoint: 'npm'
+    args: ['ci']
+  
+  - name: 'node:20'
+    entrypoint: 'npm'
+    args: ['test']
+  
+  # Build container
+  - name: 'gcr.io/cloud-builders/docker'
+    args: ['build', '-t', 'gcr.io/$PROJECT_ID/my-service:$COMMIT_SHA', '.']
+  
+  # Push to registry
+  - name: 'gcr.io/cloud-builders/docker'
+    args: ['push', 'gcr.io/$PROJECT_ID/my-service:$COMMIT_SHA']
+  
+  # Deploy to Cloud Run
+  - name: 'gcr.io/cloud-builders/gcloud'
+    args:
+      - 'run'
+      - 'deploy'
+      - 'my-service'
+      - '--image=gcr.io/$PROJECT_ID/my-service:$COMMIT_SHA'
+      - '--region=us-central1'
+      - '--platform=managed'
+
+images:
+  - 'gcr.io/$PROJECT_ID/my-service:$COMMIT_SHA'
+```
+
+---
+
+## 6. Anti-Patterns
+
+### ❌ No Min Instances
+
+```bash
+# WRONG: Cold start on every request after idle
+gcloud run deploy --min-instances 0
+
+# CORRECT: Keep warm for latency-sensitive apps
+gcloud run deploy --min-instances 1
+```
+
+### ❌ Global State Mutation
+
+```javascript
+// WRONG: Global state across requests
+let requestCount = 0;
+
+app.get('/', (req, res) => {
+  requestCount++; // Unreliable across instances!
+  res.json({ count: requestCount });
+});
+
+// CORRECT: Use external storage
+app.get('/', async (req, res) => {
+  const count = await redis.incr('request_count');
+  res.json({ count });
+});
+```
+
+---
+
+## Related Skills
+
+- `aws-serverless` - Compare with AWS
+- `azure-functions` - Compare with Azure
+- `docker-expert` - Container optimization