vibes-plug 2.11.0 → 2.14.1

package/skills/synthetic-data-finetuning-expert/SKILL.md

@@ -0,0 +1,155 @@
+---
+name: synthetic-data-finetuning-expert
+description: "Expert guide for synthetic dataset generation, LLM-as-a-judge filtering, QLoRA fine-tuning (Unsloth), DPO alignment, and GGUF/Ollama export for local SLMs / Panduan ahli generasi data sintetis, fine-tuning QLoRA, DPO, dan ekspor GGUF/Ollama."
+author: vibes-plug-swarm
+---
+
+# Synthetic Data & Fine-Tuning Expert (Custom Domain SLMs)
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Orchestration & Integration
+Connects and orchestrates with domain skills like `local-slm-edge-ai-expert`, `ai-prompt-engineering-expert`, `ai-evals-benchmark-expert`, `python-programming-expert`, and `ai-cost-token-optimizer` to build high-performance, cost-effective domain models.
+
+### Description
+Production-grade guide for generating synthetic training datasets, curating high-signal instruction pairs, executing Parameter-Efficient Fine-Tuning (QLoRA / LoRA) with **Unsloth** and Hugging Face TRL, performing Direct Preference Optimization (DPO), and quantizing custom Small Language Models (SLMs) to GGUF for edge or on-premise execution.
+
+**Swarm Synergy:** Within the **AI Engineering Swarm**, this skill serves as the Model Specialization Lead. When frontier API costs or latency become prohibitive, it trains, aligns, and deploys hyper-efficient domain SLMs (1B–8B parameters) in Phase 4.
+
+### Trigger Conditions
+- Generating domain-specific synthetic training data from seed documents, codebases, or APIs.
+- Filtering low-quality or hallucinated synthetic data using LLM-as-a-judge curation pipelines.
+- Fine-tuning open-weights models (Llama 3.3, Qwen 2.5, Mistral) on custom tasks using 4-bit QLoRA.
+- Aligning model outputs using Direct Preference Optimization (DPO) to enforce specific response styles.
+- Quantizing fine-tuned models to GGUF (q4_k_m, q8_0) for zero-latency local inference with Ollama or llama.cpp.
+
+### Synthetic Data & Fine-Tuning Lifecycle
+
+```
+1. SEED EXTRACTION & SYNTHESIS
+   [Raw Docs / Codebase] ──► [Frontier LLM / Distilabel] ──► Raw Instruction Pairs (10k+)
+
+2. QUALITY FILTERING (LLM-AS-A-JUDGE)
+   Raw Instruction Pairs ──► [Rubric Scorer / De-duplication] ──► Curated Gold Dataset (2k-5k)
+
+3. 4-BIT QLORA FINE-TUNING (UNSLOTH)
+   Base Model (e.g. Qwen 2.5-Coder) + LoRA Adapters ──► SFT / DPO Training Loop
+
+4. QUANTIZATION & LOCAL DEPLOYMENT
+   Merged 16-bit Weights ──► [llama.cpp GGUF Export] ──► Local Ollama Service (<50ms latency)
+```
+
+### Core Implementation Guidelines
+
+#### 1. Synthetic Instruction Generation & Rejection Sampling
+Use frontier models to generate input-output pairs with strict rejection criteria:
+```python
+from pydantic import BaseModel, Field
+from openai import OpenAI
+import json
+
+client = OpenAI()
+
+class SyntheticInstructionPair(BaseModel):
+    user_instruction: str = Field(description="Realistic developer query")
+    input_context: str = Field(description="Code snippet or API contract")
+    ground_truth_response: str = Field(description="Flawless, production-grade output")
+    quality_score: int = Field(ge=1, le=5, description="Self-evaluated quality score")
+
+def generate_synthetic_samples(seed_text: str) -> list[SyntheticInstructionPair]:
+    response = client.beta.chat.completions.parse(
+        model="gpt-4o-mini",
+        messages=[
+            {"role": "system", "content": "Generate 5 diverse, hard edge-case instruction pairs based on the seed code."},
+            {"role": "user", "content": seed_text}
+        ],
+        response_format=SyntheticInstructionPair,
+    )
+    # Filter out anything below score 4 (Rejection Sampling)
+    return [sample for sample in [response.choices[0].message.parsed] if sample.quality_score >= 4]
+```
+
+#### 2. High-Speed 4-Bit QLoRA with Unsloth
+Fine-tune on consumer GPUs (e.g., RTX 3090/4090 or single A10G) with 5x faster throughput:
+```python
+from unsloth import FastLanguageModel
+import torch
+from trl import SFTTrainer
+from transformers import TrainingArguments
+
+# 1. Load Model & Tokenizer in 4-bit
+max_seq_length = 2048
+model, tokenizer = FastLanguageModel.from_pretrained(
+    model_name="unsloth/Qwen2.5-Coder-7B-Instruct-bnb-4bit",
+    max_seq_length=max_seq_length,
+    load_in_4bit=True,
+)
+
+# 2. Add LoRA Adapters
+model = FastLanguageModel.get_peft_model(
+    model,
+    r=16,
+    target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
+    lora_alpha=16,
+    lora_dropout=0, # Optimized 0 dropout for Unsloth
+    bias="none",
+)
+
+# 3. Supervised Fine-Tuning (SFT)
+trainer = SFTTrainer(
+    model=model,
+    tokenizer=tokenizer,
+    train_dataset=dataset,
+    dataset_text_field="text",
+    max_seq_length=max_seq_length,
+    args=TrainingArguments(
+        per_device_train_batch_size=2,
+        gradient_accumulation_steps=4,
+        warmup_steps=10,
+        max_steps=100,
+        learning_rate=2e-4,
+        fp16=not torch.cuda.is_bf16_supported(),
+        bf16=torch.cuda.is_bf16_supported(),
+        logging_steps=1,
+        output_dir="outputs",
+    ),
+)
+trainer.train()
+```
+
+#### 3. GGUF Export for Local Ollama Deployment
+Export merged model to 4-bit or 8-bit quantized GGUF format:
+```python
+# Save to 16bit or GGUF directly
+model.save_pretrained_gguf("custom-domain-coder", tokenizer, quantization_method="q4_k_m")
+
+# Generate Modelfile for Ollama:
+# FROM ./custom-domain-coder-q4_k_m.gguf
+# PARAMETER temperature 0.2
+# SYSTEM You are an expert domain coder.
+```
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Integrasi Orkestrasi
+Terhubung dan mengorkestrasi skill domain yang relevan seperti `local-slm-edge-ai-expert`, `ai-prompt-engineering-expert`, `ai-evals-benchmark-expert`, `python-programming-expert`, dan `ai-cost-token-optimizer` untuk membangun model spesialis domain dengan performa tinggi dan biaya hemat.
+
+### Deskripsi
+Panduan produksi untuk menghasilkan dataset pelatihan sintetis, mengurasi pasangan instruksi bernilai tinggi, mengeksekusi Parameter-Efficient Fine-Tuning (QLoRA / LoRA) dengan **Unsloth** dan Hugging Face TRL, menerapkan Direct Preference Optimization (DPO), dan mengkuantisasi Small Language Models (SLM) kustom ke format GGUF untuk inferensi lokal atau on-premise berlatensi ultra-rendah.
+
+**Sinergi Swarm:** Di dalam **AI Engineering Swarm**, skill ini memegang peranan sebagai Pemimpin Spesialisasi Model. Ketika biaya API atau latensi model cloud frontier terlalu tinggi, skill ini melatih, menyelaraskan (*align*), dan men-deploy SLM domain yang sangat efisien (1B–8B parameter) pada Fase 4.
+
+### Kondisi Pemicu
+- Menghasilkan data pelatihan sintetis spesifik domain dari dokumen panduan, codebase, atau skema API.
+- Menyaring data sintetis berkualitas rendah menggunakan pipeline penilaian otomatis *LLM-as-a-judge*.
+- Melakukan fine-tuning model berbobot terbuka (Llama 3.3, Qwen 2.5, Mistral) dengan QLoRA 4-bit secara hemat memori VRAM.
+- Menyelaraskan respon model dengan Direct Preference Optimization (DPO) agar mematuhi aturan format dan gaya tertentu.
+- Mengkuantisasi model hasil fine-tuning ke format GGUF (q4_k_m, q8_0) untuk inferensi lokal instan di Ollama atau llama.cpp.

package/skills/ui-ux-pro-max/SKILL.md

@@ -58,7 +58,8 @@ python scripts/search.py "<query>" --domain <domain> --max-results 3
   - `icons`: Icon usage guidance, SVG libraries (Lucide, Heroicons), and code imports
   - `react`: React & Next.js performance optimizations, re-render fixes & dynamic imports
   - `web`: Web interface guidelines (ARIA, focus traps, virtual list, form inputs)
-  - `m3`: Material Design 3 specific design tokens, color roles, elevation, and component specs
+  - `m3`: Material Design 3 specific design tokens, color roles, elevation, and component specs
+  - `preset-monday`: Monday.com spacious SaaS aesthetic (Vibrant Blue `#0073ea`, Clean White `#FFFFFF` + Light Grays `#F9F9F9`/`#F5F6F8`, Dark Footer `#111111`, Figtree/Inter fonts, 12-16px card radius, 80-120px vertical spacing)
 
 *Example:* `python scripts/search.py "fintech dark theme" --domain color`
 
@@ -159,7 +160,8 @@ python scripts/search.py "<kueri>" --domain <domain> --max-results 3
   - `icons`: Panduan penggunaan ikon, pustaka SVG (Lucide, Heroicons), & import kode
   - `react`: Optimasi performa React & Next.js, perbaikan re-render & dynamic import
   - `web`: Pedoman antarmuka web (ARIA, focus trap, virtual list, input form)
-  - `m3`: Token desain spesifik Material Design 3, peran warna, elevasi, dan spesifikasi komponen
+  - `m3`: Token desain spesifik Material Design 3, peran warna, elevasi, dan spesifikasi komponen
+  - `preset-monday`: Estetika SaaS lapang ala Monday.com (Biru Cerah `#0073ea`, Putih Bersih `#FFFFFF` + Abu-abu Terang `#F9F9F9`/`#F5F6F8`, Footer Gelap `#111111`, font Figtree/Inter, radius kartu 12-16px, jarak seksi vertikal 80-120px)
 
 *Contoh:* `python scripts/search.py "fintech dark theme" --domain color`
 

package/skills/vercel-ai-sdk-expert/SKILL.md

@@ -0,0 +1,181 @@
+---
+name: vercel-ai-sdk-expert
+description: "Expert guide for Vercel AI SDK (Core, UI, RSC), streaming structured data, multi-provider model switching, tool calling loops, and React 19/Next.js 15 AI engineering / Panduan ahli Vercel AI SDK, streaming data terstruktur, dan integrasi AI pada React 19/Next.js 15."
+author: vibes-plug-swarm
+---
+
+# Vercel AI SDK Expert (Core, UI & Fullstack AI Engineering)
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Orchestration & Integration
+Connects and orchestrates with domain skills like `senior-frontend`, `nextjs-app-router-expert`, `ai-llm-integration-expert`, `ui-components-expert`, and `multi-agent-orchestration` to deliver reactive, streaming AI interfaces.
+
+### Description
+Production-grade guide for building AI applications using the **Vercel AI SDK (Core & UI)**. Covers unified model provider abstraction (`@ai-sdk/anthropic`, `@ai-sdk/openai`, `@ai-sdk/google`), streaming text and structured objects (`streamText`, `streamObject`), dynamic multi-step tool execution loops with `maxSteps`, client-side React 19 hooks (`useChat`, `useCompletion`), streaming data attachments (`createDataStreamResponse`), and generative UI rendering.
+
+**Swarm Synergy:** Within the **Frontend & UI Swarm**, this skill serves as the AI UI Presentation Lead. It translates complex backend multi-agent outputs and streaming tokens into accessible, beautiful web components in Phase 4 & Phase 5.
+
+### Trigger Conditions
+- Integrating conversational chat, streaming completions, or generative UI in React 19 / Next.js 15.
+- Implementing structured data extraction using `generateObject` or `streamObject` with Zod schemas.
+- Building autonomous multi-step tool-calling loops on Next.js Route Handlers or Server Actions.
+- Switching seamlessly across frontier providers (Claude 3.7 Sonnet, Gemini 3.8 Flash, OpenAI o3/GPT-4.5, Ollama).
+- Building streaming data channels with custom metadata, tool status indicators, and citations.
+
+### Vercel AI SDK Architecture (Core vs UI)
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                       CLIENT LAYER                          │
+│  useChat / useCompletion / Generative UI React Components    │
+│  • Optimistic updates  • Stream reader  • Tool invocation   │
+└──────────────────────────────▲──────────────────────────────┘
+                               │ HTTP SSE / Data Stream Protocol
+┌──────────────────────────────▼──────────────────────────────┐
+│                    SERVER ROUTE / ACTION                    │
+│  streamText({                                               │
+│    model: anthropic('claude-3-7-sonnet-20250219'),          │
+│    tools: { weatherTool, dbQueryTool },                     │
+│    maxSteps: 5,                                             │
+│  }).toDataStreamResponse()                                  │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### Core Implementation Guidelines
+
+#### 1. Next.js 15 Route Handler with Multi-Step Tool Calling Loop
+Use `streamText` with `maxSteps` to enable the model to autonomously call tools, review results, and continue reasoning:
+```typescript
+// app/api/chat/route.ts
+import { anthropic } from '@ai-sdk/anthropic';
+import { streamText, tool } from 'ai';
+import { z } from 'zod';
+
+export const maxDuration = 60; // Allow long-running agentic reasoning
+
+export async function POST(req: Request) {
+  const { messages } = await req.json();
+
+  const result = streamText({
+    model: anthropic('claude-3-7-sonnet-20250219'),
+    messages,
+    maxSteps: 5, // Enables iterative tool calling loop
+    tools: {
+      calculateMetrics: tool({
+        description: 'Computes analytical metrics from raw time series data',
+        parameters: z.object({
+          datasetId: z.string(),
+          metricType: z.enum(['p95_latency', 'error_rate', 'throughput']),
+        }),
+        execute: async ({ datasetId, metricType }) => {
+          const data = await fetchDatasetMetrics(datasetId, metricType);
+          return { datasetId, metricType, value: data.result };
+        },
+      }),
+    },
+    system: 'You are an elite software performance auditor. Always back up your conclusions with data tool outputs.',
+  });
+
+  return result.toDataStreamResponse();
+}
+```
+
+#### 2. Streaming Type-Safe Structured Objects (`streamObject`)
+Stream structured JSON objects directly into the UI while generating:
+```typescript
+import { google } from '@ai-sdk/google';
+import { streamObject } from 'ai';
+import { z } from 'zod';
+
+export async function POST(req: Request) {
+  const { codeDiff } = await req.json();
+
+  const result = streamObject({
+    model: google('gemini-2.5-flash'),
+    schema: z.object({
+      securityVulnerabilities: z.array(z.object({
+        severity: z.enum(['low', 'medium', 'high', 'critical']),
+        cwe: z.string(),
+        explanation: z.string(),
+        suggestedFix: z.string(),
+      })),
+      overallRiskScore: z.number().min(0).max(100),
+      passesReview: z.boolean(),
+    }),
+    prompt: `Audit the following git diff for security regressions:\n${codeDiff}`,
+  });
+
+  return result.toTextStreamResponse();
+}
+```
+
+#### 3. Client Hook Integration (`useChat` with Tool Invocations)
+Render real-time streaming tokens, loading skeletons, and interactive tool call results:
+```tsx
+'use client';
+
+import { useChat } from '@ai-sdk/react';
+
+export function AgenticChat() {
+  const { messages, input, handleInputChange, handleSubmit, isLoading } = useChat({
+    maxSteps: 5,
+  });
+
+  return (
+    <div className="flex flex-col h-[600px] w-full max-w-2xl mx-auto border rounded-xl p-4 bg-background">
+      <div className="flex-1 overflow-y-auto space-y-4 pr-2">
+        {messages.map((m) => (
+          <div key={m.id} className={`flex ${m.role === 'user' ? 'justify-end' : 'justify-start'}`}>
+            <div className={`p-3 rounded-lg max-w-[80%] ${m.role === 'user' ? 'bg-primary text-primary-foreground' : 'bg-muted'}`}>
+              <div className="whitespace-pre-wrap">{m.content}</div>
+              {m.toolInvocations?.map((toolInvocation) => (
+                <div key={toolInvocation.toolCallId} className="mt-2 text-xs p-2 bg-black/10 rounded">
+                  <span className="font-semibold">Tool [{toolInvocation.toolName}]:</span>{' '}
+                  {'result' in toolInvocation ? JSON.stringify(toolInvocation.result) : 'Executing...'}
+                </div>
+              ))}
+            </div>
+          </div>
+        ))}
+      </div>
+      <form onSubmit={handleSubmit} className="flex gap-2 pt-3 border-t">
+        <input
+          value={input}
+          onChange={handleInputChange}
+          placeholder="Ask the agent..."
+          className="flex-1 px-3 py-2 border rounded-md"
+        />
+        <button type="submit" disabled={isLoading} className="px-4 py-2 bg-primary text-primary-foreground rounded-md">
+          Send
+        </button>
+      </form>
+    </div>
+  );
+}
+```
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Integrasi Orkestrasi
+Terhubung dan mengorkestrasi skill domain yang relevan seperti `senior-frontend`, `nextjs-app-router-expert`, `ai-llm-integration-expert`, `ui-components-expert`, dan `multi-agent-orchestration` untuk menghadirkan antarmuka AI yang reaktif dan berlatensi rendah.
+
+### Deskripsi
+Panduan produksi untuk membangun aplikasi AI menggunakan **Vercel AI SDK (Core & UI)**. Mencakup abstraksi penyedia model terpadu (`@ai-sdk/anthropic`, `@ai-sdk/openai`, `@ai-sdk/google`), streaming teks dan objek terstruktur (`streamText`, `streamObject`), siklus eksekusi tool multi-langkah otonom dengan `maxSteps`, hook klien React 19 (`useChat`, `useCompletion`), streaming respons saluran data (`createDataStreamResponse`), dan rendering Generative UI.
+
+**Sinergi Swarm:** Di dalam **Frontend & UI Swarm**, skill ini berperan sebagai Pemimpin Presentasi UI AI. Skill ini bertugas mentransformasikan keluaran multi-agen backend dan token streaming menjadi komponen web yang interaktif, aksesibel, dan elegan pada Fase 4 & Fase 5.
+
+### Kondisi Pemicu
+- Mengintegrasikan chat percakapan, streaming respons, atau generative UI di React 19 / Next.js 15.
+- Menerapkan ekstraksi data terstruktur dengan validasi skema Zod via `generateObject` atau `streamObject`.
+- Membangun loop pemanggilan tool (*tool-calling loops*) multi-langkah di Route Handler atau Server Actions.
+- Beralih fleksibel antar penyedia model frontier (Claude 3.7 Sonnet, Gemini 3.8 Flash, OpenAI o3/GPT-4.5, Ollama).
+- Mengelola status eksekusi tool, indikator loading, dan rendering komponen UI secara dinamis saat streaming berlangsung.

package/skills/voice-ai-realtime-agent/SKILL.md

@@ -6,9 +6,21 @@ author: "Roedy Rustam"
 
 # Voice AI Realtime Agent (2026 Edition)
 
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Description
 Expert guide for building ultra-low-latency (<300ms), bi-directional conversational voice AI applications. Covers WebRTC, full-duplex WebSocket audio streaming (PCM 24kHz), OpenAI Realtime API, Gemini Multimodal Live API, LiveKit Agents SDK, and smart interruption (barge-in) handling.
 
-*Panduan ahli untuk membangun aplikasi AI suara percakapan dua arah berlatensi ultra-rendah (<300ms) menggunakan WebRTC, WebSocket full-duplex, OpenAI Realtime API, Gemini Multimodal Live API, LiveKit Agents SDK, dan penanganan interupsi (barge-in).*
+### Trigger Conditions
+- Applications requiring sub-second, spoken conversation with an AI agent.
+- Voice customer service bots, verbal copilots, language tutors, and interactive voice assistants.
+- Implementation of WebRTC audio streaming, full-duplex WebSocket audio (PCM 24kHz), and Silero VAD.
+- Setting up OpenAI Realtime API (`gpt-4o-realtime-preview`) or Gemini Multimodal Live API.
 
 ---
 
@@ -200,3 +212,31 @@ export class GeminiVoiceAgent {
 - **`realtime-collaboration-expert`**: For syncing WebRTC tracks and room states with client applications.
 - **`gemini-agent-booster`**: Connects Gemini 3.x / 2.0 Flash thinking models to live voice agents.
 - **`mobile-expo-expert`**: Audio streaming implementation in React Native with `expo-av` and WebRTC shim.
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Deskripsi
+Panduan ahli untuk membangun aplikasi AI suara percakapan dua arah berlatensi ultra-rendah (<300ms). Mencakup integrasi WebRTC, streaming audio WebSocket full-duplex (PCM 24kHz), OpenAI Realtime API, Gemini Multimodal Live API, LiveKit Agents SDK, dan penanganan interupsi cerdas (*barge-in*).
+
+### Kondisi Pemicu
+- Kebutuhan interaksi percakapan verbal instan di bawah satu detik dengan agen AI.
+- Bot layanan pelanggan berbasis suara, asisten verbal, tutor bahasa interaktif.
+- Implementasi streaming audio WebRTC, WebSocket PCM 24kHz dua arah, dan Silero Voice Activity Detection (VAD).
+- Konfigurasi OpenAI Realtime API (`gpt-4o-realtime-preview`) atau Gemini Multimodal Live API.
+
+### Panduan Inti Arsitektur Suara Real-time
+1. **Full-Duplex Speech-to-Speech**: Mengganti pipeline sekuensial tradisional (STT ➔ LLM ➔ TTS) dengan pipeline streamable WebRTC atau model native speech-to-speech untuk memangkas latensi dari ~2000ms menjadi ~300ms.
+2. **Penanganan Interupsi (Barge-In)**: Saat VAD mendeteksi suara pengguna baru saat bot sedang berbicara, buffer audio keluar harus di-flush dalam waktu <150ms tanpa menunggu LLM menyelesaikan kalimatnya.
+3. **Standar Format Audio**: Input mikrofon PCM 16-bit 16kHz/24kHz Mono, dan output speaker 24kHz untuk intonasi yang alami dan jernih.
+
+---
+
+## Integrasi Orkestrasi
+
+- **`ai-llm-integration-expert`**: Routing instruksi sistem dasar dan pemanggilan tool fungsi selama percakapan suara.
+- **`realtime-collaboration-expert`**: Sinkronisasi track audio WebRTC dan status room pengguna.
+- **`gemini-agent-booster`**: Integrasi model multimodal Gemini 2.0/3.x Flash untuk live audio.
+- **`mobile-expo-expert`**: Implementasi audio streaming di React Native menggunakan `expo-av` dan WebRTC shim.