vibes-plug 2.5.0 → 2.11.0

package/skills/glsl-shader-expert/SKILL.md

@@ -1,101 +1,107 @@
----
-name: glsl-shader-expert
-description: "Expert guide for writing custom GLSL shaders (Vertex/Fragment) for WebGL using Three.js and Babylon.js. Covers shader materials, post-processing, noise, and performance optimization."
+---
+name: glsl-shader-expert
+description: "Expert guide for writing custom GLSL shaders (Vertex/Fragment) for WebGL using Three.js and Babylon.js. Covers shader materials, post-processing, noise, and performance optimization."
 author: "Roedy Rustam"
----
-
-# GLSL Shader Expert (WebGL 3D Graphics)
-
-[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
-
----
-
-<a name="english"></a>
-## English
-
-### Description
-Production-grade guidance for writing and integrating custom GLSL (OpenGL Shading Language) shaders into web applications using **Three.js** (`ShaderMaterial` / `RawShaderMaterial`) or **Babylon.js** (`ShaderMaterial`). Focuses on creating advanced visual effects, custom lighting models, procedural textures (noise), and post-processing passes.
-
-### Trigger Conditions
-Activate this skill when the user is:
-- Asking to create custom materials that standard PBR materials cannot achieve.
-- Writing Vertex or Fragment shaders in GLSL.
-- Implementing procedural generation (e.g., Perlin noise, Simplex noise) on the GPU.
-- Creating post-processing effects or screen-space shaders.
-- Optimizing GPU performance by moving CPU calculations to vertex shaders.
-
-### Core Concepts
-
-#### 1. The Graphics Pipeline
-Understand the flow:
-1. **Vertex Shader:** Runs for every vertex. Used to manipulate geometry (position) and pass data (varyings) to the fragment shader. Must set `gl_Position`.
-2. **Fragment Shader:** Runs for every pixel (fragment). Used to determine color. Must set `gl_FragColor`.
-
-#### 2. Three.js `ShaderMaterial` Example
-```javascript
-import * as THREE from 'three';
-
-const vertexShader = `
-  varying vec2 vUv;
-  void main() {
-    vUv = uv;
-    // Standard projection
-    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
-  }
-`;
-
-const fragmentShader = `
-  uniform float uTime;
-  varying vec2 vUv;
-  void main() {
-    // Simple animated color based on UV coordinates and time
-    vec3 color = vec3(vUv.x, vUv.y, sin(uTime) * 0.5 + 0.5);
-    gl_FragColor = vec4(color, 1.0);
-  }
-`;
-
-const material = new THREE.ShaderMaterial({
-  vertexShader,
-  fragmentShader,
-  uniforms: {
-    uTime: { value: 0 }
-  }
-});
-```
-*Note: In the render loop, you must update `material.uniforms.uTime.value += delta;`*
-
-#### 3. Best Practices for Shaders
-- **Avoid Branching:** GPU threads run in lockstep (warps/wavefronts). `if/else` statements can cause significant performance drops. Prefer mathematical functions like `step()`, `smoothstep()`, `mix()`, and `clamp()`.
-- **Precision:** Explicitly declare float precision (`precision mediump float;` or `highp` if necessary). Use `mediump` for colors/UVs to save performance, particularly on mobile.
-- **Use Uniforms Wisely:** Only pass data that changes per frame or per object as uniforms.
-
----
-
-### Integration with Other Skills (MANDATORY)
-This skill works best when combined with:
-- `web-3d-graphics-expert` — For setting up the core WebGL scene in Three.js/Babylon.js.
-- `web-game-engine-expert` — For linking shader uniforms with physics data (e.g., impact ripples).
-- `ui-ux-pro-max` — For ensuring shader visual effects match the modern Web design tokens.
-
-### Referenced By Orchestrators (MANDATORY)
-- `brainstorming` — Add to "3D & Graphics" or "UI/UX & Design Systems".
-- `zero-to-prod-orchestrator` — Phase 5 (Frontend / WebGL Implementation).
-
----
-
-<a name="bahasa-indonesia"></a>
-## Bahasa Indonesia
-
-### Deskripsi
-Panduan ahli untuk menulis dan mengintegrasikan shader GLSL khusus ke dalam aplikasi web menggunakan **Three.js** atau **Babylon.js**. Mencakup pembuatan *Vertex Shader*, *Fragment Shader*, efek visual prosedural, dan optimasi GPU.
-
-### Kondisi Pemicu
-- Saat pengguna ingin membuat efek visual kustom (seperti air, hologram, distorsi) yang tidak bisa dilakukan oleh material standar.
-- Menulis kode GLSL untuk *ShaderMaterial*.
-- Mengoptimalkan performa grafis dengan memindahkan komputasi CPU ke GPU.
-
-### Panduan Singkat
-- **Vertex vs Fragment:** *Vertex shader* mengatur posisi dan memanipulasi geometri (`gl_Position`), sedangkan *Fragment shader* mengatur pewarnaan setiap pixel (`gl_FragColor`).
-- **Hindari If/Else:** CPU sangat cepat dalam percabangan (`if/else`), tetapi GPU sangat lambat. Gunakan fungsi interpolasi matematika bawaan GLSL seperti `step()`, `smoothstep()`, dan `mix()`.
-- **Gunakan Uniforms:** Gunakan `uniforms` untuk mengirim data dari JavaScript (seperti waktu, posisi mouse, atau tekstur) ke dalam shader. Update nilai uniform ini di dalam *render loop*.
-- **Presisi (Precision):** Gunakan `precision mediump float;` secara default untuk menyeimbangkan performa dan kualitas visual, terutama untuk optimalisasi *mobile*.
+---
+
+# GLSL Shader Expert (WebGL 3D Graphics)
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Orchestration & Integration
+Connects and orchestrates with relevant domain skills like `brainstorming`, `zero-to-prod-orchestrator`, and `project-context-mapper` to ensure cohesive execution.
+
+### Description
+Production-grade guidance for writing and integrating custom GLSL (OpenGL Shading Language) shaders into web applications using **Three.js** (`ShaderMaterial` / `RawShaderMaterial`) or **Babylon.js** (`ShaderMaterial`). Focuses on creating advanced visual effects, custom lighting models, procedural textures (noise), and post-processing passes.
+
+### Trigger Conditions
+Activate this skill when the user is:
+- Asking to create custom materials that standard PBR materials cannot achieve.
+- Writing Vertex or Fragment shaders in GLSL.
+- Implementing procedural generation (e.g., Perlin noise, Simplex noise) on the GPU.
+- Creating post-processing effects or screen-space shaders.
+- Optimizing GPU performance by moving CPU calculations to vertex shaders.
+
+### Core Concepts
+
+#### 1. The Graphics Pipeline
+Understand the flow:
+1. **Vertex Shader:** Runs for every vertex. Used to manipulate geometry (position) and pass data (varyings) to the fragment shader. Must set `gl_Position`.
+2. **Fragment Shader:** Runs for every pixel (fragment). Used to determine color. Must set `gl_FragColor`.
+
+#### 2. Three.js `ShaderMaterial` Example
+```javascript
+import * as THREE from 'three';
+
+const vertexShader = `
+  varying vec2 vUv;
+  void main() {
+    vUv = uv;
+    // Standard projection
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+
+const fragmentShader = `
+  uniform float uTime;
+  varying vec2 vUv;
+  void main() {
+    // Simple animated color based on UV coordinates and time
+    vec3 color = vec3(vUv.x, vUv.y, sin(uTime) * 0.5 + 0.5);
+    gl_FragColor = vec4(color, 1.0);
+  }
+`;
+
+const material = new THREE.ShaderMaterial({
+  vertexShader,
+  fragmentShader,
+  uniforms: {
+    uTime: { value: 0 }
+  }
+});
+```
+*Note: In the render loop, you must update `material.uniforms.uTime.value += delta;`*
+
+#### 3. Best Practices for Shaders
+- **Avoid Branching:** GPU threads run in lockstep (warps/wavefronts). `if/else` statements can cause significant performance drops. Prefer mathematical functions like `step()`, `smoothstep()`, `mix()`, and `clamp()`.
+- **Precision:** Explicitly declare float precision (`precision mediump float;` or `highp` if necessary). Use `mediump` for colors/UVs to save performance, particularly on mobile.
+- **Use Uniforms Wisely:** Only pass data that changes per frame or per object as uniforms.
+
+---
+
+### Integration with Other Skills (MANDATORY)
+This skill works best when combined with:
+- `web-3d-graphics-expert` — For setting up the core WebGL scene in Three.js/Babylon.js.
+- `web-game-engine-expert` — For linking shader uniforms with physics data (e.g., impact ripples).
+- `ui-ux-pro-max` — For ensuring shader visual effects match the modern Web design tokens.
+
+### Referenced By Orchestrators (MANDATORY)
+- `brainstorming` — Add to "3D & Graphics" or "UI/UX & Design Systems".
+- `zero-to-prod-orchestrator` — Phase 5 (Frontend / WebGL Implementation).
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Integrasi Orkestrasi
+Terhubung dan mengorkestrasi skill domain yang relevan seperti `brainstorming`, `zero-to-prod-orchestrator`, dan `project-context-mapper` untuk memastikan eksekusi yang kohesif.
+
+### Deskripsi
+Panduan ahli untuk menulis dan mengintegrasikan shader GLSL khusus ke dalam aplikasi web menggunakan **Three.js** atau **Babylon.js**. Mencakup pembuatan *Vertex Shader*, *Fragment Shader*, efek visual prosedural, dan optimasi GPU.
+
+### Kondisi Pemicu
+- Saat pengguna ingin membuat efek visual kustom (seperti air, hologram, distorsi) yang tidak bisa dilakukan oleh material standar.
+- Menulis kode GLSL untuk *ShaderMaterial*.
+- Mengoptimalkan performa grafis dengan memindahkan komputasi CPU ke GPU.
+
+### Panduan Singkat
+- **Vertex vs Fragment:** *Vertex shader* mengatur posisi dan memanipulasi geometri (`gl_Position`), sedangkan *Fragment shader* mengatur pewarnaan setiap pixel (`gl_FragColor`).
+- **Hindari If/Else:** CPU sangat cepat dalam percabangan (`if/else`), tetapi GPU sangat lambat. Gunakan fungsi interpolasi matematika bawaan GLSL seperti `step()`, `smoothstep()`, dan `mix()`.
+- **Gunakan Uniforms:** Gunakan `uniforms` untuk mengirim data dari JavaScript (seperti waktu, posisi mouse, atau tekstur) ke dalam shader. Update nilai uniform ini di dalam *render loop*.
+- **Presisi (Precision):** Gunakan `precision mediump float;` secara default untuk menyeimbangkan performa dan kualitas visual, terutama untuk optimalisasi *mobile*.

package/skills/go-programming-expert/SKILL.md

@@ -1,10 +1,10 @@
 ---
 name: go-programming-expert
-description: "Expert-level skill for Go programming (Go 1.23/1.24+). Covers high-performance microservices, concurrency patterns, sqlc, net/http, Gin/Echo/Fiber, gRPC, and testing in English and Indonesian."
-author: "Roedy Rustam"
+description: "Expert-level skill for Go programming (Go 1.25+). Covers high-performance microservices, concurrency patterns, sqlc, net/http, Gin/Echo/Fiber, gRPC, and testing in English and Indonesian."
+author: "Roedy Rustam"
 ---
 
-# Go Programming Expert (Go 1.24 Edition)
+# Go Programming Expert (Go 1.25 Edition)
 
 [English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
 
@@ -13,11 +13,14 @@ author: "Roedy Rustam"
 <a name="english"></a>
 ## English
 
+### Orchestration & Integration
+Connects and orchestrates with relevant domain skills like `brainstorming`, `zero-to-prod-orchestrator`, and `project-context-mapper` to ensure cohesive execution.
+
 ### Description
-Expert-level Go development for building high-performance microservices, APIs, and CLI tools. Covers **Go 1.24** features (range-over-func iterators, generic type aliases, weak pointers), structured logging with `slog`, `net/http` with the new ServeMux patterns, Gin/Echo/Fiber frameworks, sqlc for type-safe SQL, gRPC, and production testing patterns.
+Expert-level Go development for building high-performance microservices, APIs, and CLI tools. Covers **Go 1.25** features (range-over-func iterators, generic type aliases, weak pointers), structured logging with `slog`, `net/http` with the new ServeMux patterns, Gin/Echo/Fiber frameworks, sqlc for type-safe SQL, gRPC, and production testing patterns.
 
 ### Trigger Conditions
-- Writing Go 1.23+ / 1.24+ microservices or APIs.
+- Writing Go 1.24+ / 1.25+ microservices or APIs.
 - Implementing concurrency patterns with goroutines, channels, and `sync` primitives.
 - Using structured logging with `log/slog`.
 - Building HTTP servers with `net/http` ServeMux (Go 1.22+) or Gin/Echo/Fiber.
@@ -25,9 +28,9 @@ Expert-level Go development for building high-performance microservices, APIs, a
 - Implementing gRPC services with protobuf.
 - Writing Go tests with the standard `testing` package + `testify`.
 
-### Go 1.24 — Key Features
+### Go 1.25 — Key Features
 
-#### Range-Over-Func (Go 1.22 → Stable in 1.24)
+#### Range-Over-Func (Go 1.22 → Stable in 1.24/1.25)
 Range over custom iterators — enables functional-style collection operations:
 ```go
 // Define an iterator function
@@ -52,7 +55,7 @@ for n := range Fibonacci() {
 }
 ```
 
-#### Generic Type Aliases (Go 1.24)
+#### Generic Type Aliases (Go 1.24/1.25)
 ```go
 // Type alias with generic parameters
 type Set[T comparable] = map[T]struct{}
@@ -62,7 +65,7 @@ type Result[T any] = struct{ Value T; Err error }
 var s Set[string] = make(map[string]struct{})
 ```
 
-#### Weak Pointers (Go 1.24)
+#### Weak Pointers (Go 1.24/1.25)
 ```go
 import "weak"
 
@@ -250,24 +253,27 @@ func TestGetUser(t *testing.T) {
 <a name="bahasa-indonesia"></a>
 ## Bahasa Indonesia
 
+### Integrasi Orkestrasi
+Terhubung dan mengorkestrasi skill domain yang relevan seperti `brainstorming`, `zero-to-prod-orchestrator`, dan `project-context-mapper` untuk memastikan eksekusi yang kohesif.
+
 ### Deskripsi
-Panduan Go tingkat ahli untuk membangun microservices, API, dan CLI tool berkinerja tinggi. Mencakup fitur **Go 1.24** (range-over-func, generic type alias, weak pointer), structured logging dengan `slog`, ServeMux `net/http` dengan pola baru (Go 1.22+), framework Gin/Echo/Fiber, sqlc untuk SQL type-safe, gRPC, dan pola pengujian produksi.
+Panduan Go tingkat ahli untuk membangun microservices, API, dan CLI tool berkinerja tinggi. Mencakup fitur **Go 1.25** (range-over-func, generic type alias, weak pointer), structured logging dengan `slog`, ServeMux `net/http` dengan pola baru (Go 1.22+), framework Gin/Echo/Fiber, sqlc untuk SQL type-safe, gRPC, dan pola pengujian produksi.
 
 ### Kondisi Pemicu
-- Menulis microservices atau API Go 1.23+/1.24+.
+- Menulis microservices atau API Go 1.24+/1.25+.
 - Mengimplementasikan pola konkurensi dengan goroutine, channel, dan primitif `sync`.
 - Menggunakan structured logging dengan `log/slog`.
 - Membangun HTTP server dengan ServeMux `net/http` (Go 1.22+) atau Gin/Echo/Fiber.
 - Menulis SQL type-safe dengan **sqlc** atau GORM.
 - Mengimplementasikan layanan gRPC dengan protobuf.
 
-### Go 1.24 — Fitur Utama
+### Go 1.25 — Fitur Utama
 
-#### Range-Over-Func (Stabil di 1.24)
-Go 1.24 menstabilkan range over iterator function — memungkinkan koleksi gaya fungsional yang idiomatis tanpa mengekspos slice internal.
+#### Range-Over-Func (Stabil di 1.24/1.25)
+Go 1.24/1.25 menstabilkan range over iterator function — memungkinkan koleksi gaya fungsional yang idiomatis tanpa mengekspos slice internal.
 
 #### Generic Type Alias
-Go 1.24 memungkinkan alias tipe dengan parameter generic, meningkatkan komposibilitas tipe.
+Go 1.24/1.25 memungkinkan alias tipe dengan parameter generic, meningkatkan komposibilitas tipe.
 
 #### Weak Pointer
 `weak.Make()` membuat pointer lemah yang tidak mencegah GC mengumpulkan objek — berguna untuk cache.

package/skills/graph-rag-knowledge-expert/SKILL.md

@@ -0,0 +1,159 @@
+---
+name: graph-rag-knowledge-expert
+description: "Expert guide for Knowledge Graphs, GraphRAG, Microsoft GraphRAG, Neo4j Text2Cypher, multi-hop relational retrieval, and hybrid vector-graph search / Panduan ahli Knowledge Graph, GraphRAG, dan pencarian relasional multi-hop."
+author: "Roedy Rustam"
+---
+
+# GraphRAG & Knowledge Graph Expert (2026 Edition)
+
+Expert guide for implementing Knowledge Graph-augmented Retrieval (GraphRAG), solving the fatal weaknesses of vector search: multi-hop reasoning, relationship discovery, and global corpus understanding. Covers Microsoft GraphRAG, Neo4j Text2Cypher, FalkorDB, and hybrid Vector + Graph retrieval pipelines.
+
+*Panduan ahli untuk implementasi Knowledge Graph dan GraphRAG untuk mengatasi kelemahan mendasar vector search murni dalam pemikiran multi-hop, deteksi relasi entitas tersembunyi, dan ringkasan global korpus.*
+
+---
+
+## 1. Why GraphRAG Over Pure Vector Search?
+
+| Capability | Pure Vector Search (RAG) | GraphRAG (Graph + Vector) |
+| :--- | :--- | :--- |
+| **Direct Similarity ("What is X?")** | 🟢 Fast, accurate | 🟢 High accuracy |
+| **Multi-Hop Traversal ("How does X affect Z via Y?")** | 🔴 Blind (returns fragmented chunks) | 🟢 Explores interconnected graph edges |
+| **Global Corpus Query ("What are the main themes across all documents?")** | 🔴 Fails (limited to Top-K chunks) | 🟢 Hierarchical Community Summaries |
+| **Hallucination Rate on Complex Queries** | 🔴 Moderate to High (context stitching) | 🟢 Grounded in explicit knowledge edges |
+
+---
+
+## 2. Production Recipe: Text2Cypher Knowledge Graph Querying (TypeScript)
+
+Using Neo4j with deterministic schema introspection, preventing arbitrary syntax hallucinations.
+
+```typescript
+// text2cypher.ts - Safe Neo4j Query Generation & Execution
+import neo4j, { Driver } from 'neo4j-driver';
+import { generateText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+
+export class GraphRAGService {
+  private driver: Driver;
+
+  constructor(uri: string, user: string, pass: string) {
+    this.driver = neo4j.driver(uri, neo4j.auth.basic(user, pass));
+  }
+
+  // 1. Fetch live Graph Schema to ground the LLM
+  private async getGraphSchema(): Promise<string> {
+    const session = this.driver.session();
+    try {
+      const result = await session.run(`
+        CALL apoc.meta.schema() YIELD value
+        RETURN value
+      `);
+      return JSON.stringify(result.records[0]?.get('value') || {});
+    } finally {
+      await session.close();
+    }
+  }
+
+  // 2. Synthesize strict read-only Cypher query
+  public async queryGraph(userQuestion: string): Promise<any[]> {
+    const schema = await this.getGraphSchema();
+
+    const { text: cypherQuery } = await generateText({
+      model: openai('gpt-4o-mini'),
+      system: `
+        You are an expert Neo4j Cypher generator.
+        Generate ONLY valid, read-only CYPHER queries based on this schema:
+        ${schema}
+
+        Rules:
+        - Never generate CREATE, MERGE, DELETE, or SET statements.
+        - Always use parameterization where appropriate.
+        - Output ONLY the raw Cypher query, without markdown or backticks.
+      `,
+      prompt: `Translate this question into Cypher: ${userQuestion}`,
+    });
+
+    const sanitizedCypher = cypherQuery.trim().replace(/^```cypher|```$/g, '');
+
+    // 3. Execute with read-only transaction
+    const session = this.driver.session({ defaultAccessMode: neo4j.session.READ });
+    try {
+      const res = await session.run(sanitizedCypher);
+      return res.records.map((r) => r.toObject());
+    } finally {
+      await session.close();
+    }
+  }
+
+  public async close(): Promise<void> {
+    await this.driver.close();
+  }
+}
+```
+
+---
+
+## 3. Production Recipe: Entity & Relation Extraction (Python)
+
+```python
+# graph_extractor.py - Structured Entity & Relation Extraction
+from typing import List
+from pydantic import BaseModel, Field
+import instructor
+from openai import OpenAI
+
+client = instructor.from_openai(OpenAI())
+
+class Entity(BaseModel):
+    name: str = Field(description="Normalized entity name, uppercase")
+    type: str = Field(description="ORGANIZATION, PERSON, TECHNOLOGY, CONCEPT, LOCATION")
+    description: str = Field(description="Summary of entity role")
+
+class Relationship(BaseModel):
+    source_entity: str
+    target_entity: str
+    relation_type: str = Field(description="USES, DEVELOPS, OWNS, LOCATED_IN, DEPENDS_ON")
+    weight: float = Field(default=1.0, ge=0.0, le=1.0)
+    description: str
+
+class KnowledgeGraph(BaseModel):
+    entities: List[Entity]
+    relationships: List[Relationship]
+
+def extract_knowledge_graph(document_text: str) -> KnowledgeGraph:
+    """Extracts entities and relationships from raw text into structured schema."""
+    return client.chat.completions.create(
+        model="gpt-4o-mini",
+        response_model=KnowledgeGraph,
+        messages=[
+            {
+                "role": "system",
+                "content": (
+                    "Extract all named entities and factual relationships between them. "
+                    "Ensure entity names are canonicalized and relationships are directed."
+                ),
+            },
+            {"role": "user", "content": document_text},
+        ],
+        temperature=0.0,
+    )
+```
+
+---
+
+## 4. Microsoft GraphRAG: Hierarchical Communities
+
+For high-level summaries ("Summarize all technical debts reported across the system"):
+1. **Extraction**: Chunk documents ➔ Extract Entities & Relationships.
+2. **Clustering**: Apply **Leiden Algorithm** to detect hierarchical communities (Level 0: Micro, Level 1: Sub-domain, Level 2: Macro domain).
+3. **Summarization**: LLM generates pre-computed summaries for each community cluster.
+4. **Global Search**: Query runs across pre-computed community summaries in parallel, eliminating the need to read millions of tokens at inference time.
+
+---
+
+## Orchestration & Integration
+
+- **`vector-db-rag-expert`**: For hybrid dense-vector similarity search combined with graph path discovery.
+- **`database-orm-expert`**: For maintaining transactional relational mappings alongside graph stores.
+- **`ai-llm-integration-expert`**: Connects reasoning models to multi-hop graph context.
+- **`search-engine-expert`**: For keyword lexical indexing of graph node attributes.