vibes-plug 1.0.0

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

@@ -0,0 +1,271 @@
+---
+name: python-programming-expert
+description: "Expert-level skill for Python programming (Python 3.12/3.13+). Covers type safety, generic syntax (PEP 695), async/await TaskGroups, FastAPI 0.115+, Pydantic v2, uv package manager, Ruff, and pytest in English and Indonesian."
+author: "Roedy Rustam"
+---
+
+# Python Programming Expert (3.13 JIT Edition)
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Description
+Expert-level Python development guidance for **Python 3.13+** with JIT compiler, covering type safety, async patterns, modern web frameworks (FastAPI 0.115+, Django 5.x), Pydantic v2, the `uv` package manager, Ruff linting, and production-grade testing with pytest.
+
+### Trigger Conditions
+- Writing Python 3.12+ / 3.13+ applications or services.
+- Building FastAPI 0.115+ REST APIs or Django 5.x web apps.
+- Managing Python projects with the `uv` package manager.
+- Implementing async/await patterns with `asyncio.TaskGroup`.
+- Writing type-safe Python with Pydantic v2 and modern generics (PEP 695).
+- Setting up Ruff for linting + formatting, pytest for testing.
+
+### Python 3.13 — Key Improvements
+
+#### JIT Compiler (Experimental → Production-Ready)
+Python 3.13 ships with an **experimental JIT compiler** based on copy-and-patch. Enable it for CPU-bound workloads:
+```bash
+python3.13 --enable-experimental-jit app.py
+# Or via env var:
+PYTHON_JIT=1 python3.13 app.py
+```
+Expected 10-20% speedup for numeric/algorithmic code. Not yet beneficial for I/O-bound async code.
+
+#### Free-Threaded Mode (No GIL)
+Python 3.13 introduces an experimental **free-threaded build** (no GIL), enabling true CPU parallelism with threads:
+```bash
+# Install free-threaded build
+uv python install 3.13t
+python3.13t -X gil=0 my_parallel_app.py
+```
+
+#### Improved Error Messages
+Python 3.13 provides significantly better tracebacks with highlighted variable values and suggestions.
+
+### Modern Python Toolchain (2026)
+
+#### uv — The 2026 Standard Package Manager
+Replace `pip`, `pip-tools`, `virtualenv`, `pyenv`, and `poetry` with **uv**:
+```bash
+# Create project
+uv init my-project
+cd my-project
+
+# Add dependencies
+uv add fastapi pydantic httpx
+
+# Add dev dependencies
+uv add --dev pytest ruff mypy
+
+# Run scripts
+uv run python main.py
+uv run pytest
+
+# Sync environment
+uv sync
+
+# Lock dependencies
+uv lock
+```
+
+#### Ruff — Linting + Formatting in One
+```bash
+uv add --dev ruff
+
+# ruff.toml
+[tool.ruff]
+line-length = 88
+target-version = "py313"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "N", "UP", "B", "SIM", "ANN"]
+
+# Run
+uv run ruff check .
+uv run ruff format .
+```
+
+### Type Safety — Modern Patterns (Python 3.12+)
+
+#### PEP 695 — New Generic Syntax
+```python
+# Old (Python < 3.12)
+from typing import TypeVar
+T = TypeVar('T')
+def first[T](lst: list[T]) -> T: ...
+
+# New (Python 3.12+) — cleaner, no TypeVar boilerplate
+def first[T](lst: list[T]) -> T:
+    return lst[0]
+
+type Vector = list[float]  # Type alias with 'type' statement
+```
+
+#### Pydantic v2 — Data Validation
+```python
+from pydantic import BaseModel, Field, field_validator
+from pydantic import EmailStr
+
+class UserCreate(BaseModel):
+    name: str = Field(min_length=2, max_length=50)
+    email: EmailStr
+    age: int = Field(ge=0, le=150)
+
+    @field_validator('name')
+    @classmethod
+    def name_must_not_contain_space(cls, v: str) -> str:
+        if '  ' in v:
+            raise ValueError('Name must not have double spaces')
+        return v.strip()
+
+# Usage
+user = UserCreate(name="Alice", email="alice@example.com", age=30)
+user.model_dump()  # {'name': 'Alice', 'email': 'alice@example.com', 'age': 30}
+```
+
+### FastAPI 0.115+ Best Practices
+
+#### Lifespan (Replace @app.on_event)
+```python
+from contextlib import asynccontextmanager
+from fastapi import FastAPI
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Startup: connect DB, warm caches
+    await db.connect()
+    yield
+    # Shutdown: clean up resources
+    await db.disconnect()
+
+app = FastAPI(lifespan=lifespan)
+```
+
+#### Dependency Injection Pattern
+```python
+from fastapi import Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+
+async def get_db() -> AsyncSession:
+    async with async_session_factory() as session:
+        yield session
+
+@app.get("/users/{user_id}")
+async def get_user(user_id: str, db: AsyncSession = Depends(get_db)):
+    user = await db.get(User, user_id)
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    return user
+```
+
+#### Structured Error Responses
+```python
+from fastapi import Request
+from fastapi.responses import JSONResponse
+
+class AppError(Exception):
+    def __init__(self, message: str, code: str, status: int = 400):
+        self.message = message
+        self.code = code
+        self.status = status
+
+@app.exception_handler(AppError)
+async def app_error_handler(request: Request, exc: AppError):
+    return JSONResponse(
+        status_code=exc.status,
+        content={"error": exc.code, "message": exc.message}
+    )
+```
+
+### Async Patterns — asyncio.TaskGroup (Python 3.11+)
+```python
+import asyncio
+
+async def main():
+    async with asyncio.TaskGroup() as tg:
+        task_a = tg.create_task(fetch_data("A"))
+        task_b = tg.create_task(fetch_data("B"))
+    # Both tasks complete or any exception is raised
+    results = [task_a.result(), task_b.result()]
+```
+
+### Testing with pytest
+```python
+import pytest
+import pytest_asyncio
+from httpx import AsyncClient, ASGITransport
+
+@pytest_asyncio.fixture
+async def client():
+    async with AsyncClient(
+        transport=ASGITransport(app=app), base_url="http://test"
+    ) as ac:
+        yield ac
+
+@pytest.mark.asyncio
+async def test_get_user(client: AsyncClient):
+    response = await client.get("/users/123")
+    assert response.status_code == 200
+    assert response.json()["id"] == "123"
+```
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Deskripsi
+Panduan pengembangan Python tingkat ahli untuk **Python 3.13+** dengan JIT compiler, mencakup keamanan tipe, pola async, framework web modern (FastAPI 0.115+, Django 5.x), Pydantic v2, manajer paket `uv`, Ruff, dan pengujian produksi dengan pytest.
+
+### Kondisi Pemicu
+- Menulis aplikasi atau layanan Python 3.12+/3.13+.
+- Membangun REST API FastAPI 0.115+ atau aplikasi web Django 5.x.
+- Mengelola proyek Python dengan manajer paket `uv`.
+- Mengimplementasikan pola async/await dengan `asyncio.TaskGroup`.
+- Menulis Python type-safe dengan Pydantic v2 dan generik modern (PEP 695).
+- Menyiapkan Ruff untuk linting + formatting, pytest untuk pengujian.
+
+### Python 3.13 — Peningkatan Utama
+
+#### JIT Compiler
+Python 3.13 hadir dengan **JIT compiler eksperimental** berbasis copy-and-patch. Aktifkan dengan `--enable-experimental-jit` atau variabel lingkungan `PYTHON_JIT=1`. Perkiraan peningkatan kecepatan 10-20% untuk kode CPU-bound.
+
+#### Free-Threaded Mode (Tanpa GIL)
+Python 3.13 memperkenalkan **build free-threaded eksperimental** (tanpa GIL), memungkinkan paralelisme CPU sejati dengan thread.
+
+### Toolchain Modern (2026)
+
+#### uv — Manajer Paket Standar 2026
+Gantikan `pip`, `pip-tools`, `virtualenv`, `pyenv`, dan `poetry` dengan **uv** — jauh lebih cepat dan terintegrasi dalam satu alat. Gunakan `uv init`, `uv add`, `uv run`, dan `uv sync` untuk semua operasi proyek.
+
+#### Ruff — Linting + Formatting Dalam Satu Alat
+Ruff menggantikan Flake8, isort, Black, dan pyupgrade sekaligus — jauh lebih cepat karena ditulis dalam Rust.
+
+### Keamanan Tipe — Pola Modern
+
+#### PEP 695 — Sintaksis Generic Baru
+Python 3.12+ memperkenalkan sintaksis generic yang lebih bersih tanpa boilerplate `TypeVar`. Gunakan pernyataan `type` untuk alias tipe.
+
+#### Pydantic v2
+Gunakan `BaseModel`, `Field`, dan `@field_validator` untuk validasi data yang ketat. `model_dump()` dan `model_validate()` menggantikan metode lama.
+
+### FastAPI 0.115+ Best Practices
+
+#### Lifespan (Gantikan @app.on_event)
+Gunakan `@asynccontextmanager` dengan parameter `lifespan` di `FastAPI()` untuk startup/shutdown yang bersih.
+
+#### Dependency Injection
+Gunakan `Depends()` untuk injeksi sesi database, autentikasi, dan dependensi lainnya ke route handler.
+
+#### Error Terstruktur
+Buat kelas `Exception` kustom dan daftarkan `exception_handler` global untuk respons error yang konsisten.
+
+### Pola Async — asyncio.TaskGroup
+Gunakan `asyncio.TaskGroup` (Python 3.11+) sebagai pengganti `asyncio.gather()` yang lebih aman — secara otomatis membatalkan semua task lain jika salah satu gagal.
+
+### Pengujian dengan pytest
+Gunakan `pytest-asyncio` dan `AsyncClient` dari `httpx` untuk pengujian endpoint async FastAPI yang bersih dan terisolasi.

package/skills/realtime-collaboration-expert/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: realtime-collaboration-expert
+description: "Expert guide for building real-time collaboration features using WebSockets, WebRTC, CRDTs (Yjs, Automerge), and Liveblocks / Panduan ahli untuk fitur kolaborasi real-time."
+author: "Antigravity"
+---
+
+# Real-Time Collaboration Expert / Ahli Kolaborasi Real-Time
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Description
+Expert guide for implementing multiplayer, real-time collaboration features in web applications. Covers Conflict-free Replicated Data Types (CRDTs) like Yjs/Automerge, WebSockets, WebRTC, and Managed services like Liveblocks or Pusher.
+
+### Instructions
+- **CRDTs for State**: Use CRDTs (e.g., `yjs` or `automerge`) instead of Operational Transformation (OT) for handling distributed state and concurrent document editing smoothly.
+- **Connection Resiliency**: Always implement automatic reconnection logic with exponential backoff for WebSockets. Handle offline states gracefully by syncing local changes once reconnected.
+- **Presence & Awareness**: Implement presence indicators (who is online, cursor positions) separated from the core document state to reduce bandwidth and storage overhead.
+- **Security in Real-time**: Authenticate and authorize every WebSocket connection upon establishment and validate all incoming socket messages to prevent malicious payloads.
+- **Scale**: Be mindful of message broadcasting limits. Use Redis Pub/Sub or similar message brokers when scaling WebSocket servers across multiple instances.
+
+### Trigger Conditions
+Active whenever the user is building multiplayer features, live cursors, document co-editing, real-time chats, or working with WebSockets, Yjs, or WebRTC.
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Deskripsi
+Panduan ahli untuk mengimplementasikan fitur kolaborasi real-time dan *multiplayer* pada aplikasi web. Mencakup Conflict-free Replicated Data Types (CRDTs) seperti Yjs/Automerge, WebSockets, WebRTC, dan layanan terkelola seperti Liveblocks atau Pusher.
+
+### Instruksi
+- **CRDT untuk State**: Gunakan CRDT (misalnya `yjs` atau `automerge`) daripada Operational Transformation (OT) untuk menangani *state* terdistribusi dan pengeditan dokumen secara bersamaan dengan lancar.
+- **Ketahanan Koneksi**: Selalu terapkan logika penyambungan ulang otomatis dengan *exponential backoff* untuk WebSockets. Tangani *offline state* dengan baik dengan menyinkronkan perubahan lokal setelah tersambung kembali.
+- **Presence & Awareness**: Terapkan indikator kehadiran (siapa yang sedang online, posisi kursor) yang dipisahkan dari status dokumen inti untuk mengurangi *overhead* bandwidth dan penyimpanan.
+- **Keamanan Real-time**: Lakukan autentikasi dan otorisasi setiap koneksi WebSocket pada saat tersambung dan validasi semua pesan *socket* yang masuk untuk mencegah *payload* berbahaya.
+- **Skalabilitas**: Perhatikan batas penyiaran (broadcasting) pesan. Gunakan Redis Pub/Sub atau *message broker* serupa saat meningkatkan (scaling) server WebSocket di beberapa instans.
+
+### Kondisi Pemicu
+Aktif setiap kali pengguna sedang membangun fitur *multiplayer*, kursor langsung (live cursors), pengeditan dokumen bersama, obrolan real-time, atau bekerja dengan WebSockets, Yjs, atau WebRTC.

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

@@ -0,0 +1,235 @@
+---
+name: rust-programming-expert
+description: "Expert-level skill for Rust programming (Rust 2024 / v1.85+). Covers memory safety, async, Axum/SQLx, CLI, and optimization in English and Indonesian."
+author: "Roedy Rustam"
+---
+
+# Rust Programming Expert (2024 Edition / v1.88+)
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Description
+Expert-level Rust development for building memory-safe, high-performance systems, APIs, CLI tools, and WebAssembly. Covers the **Rust 2024 edition**, async/await with Tokio, Axum 0.8 web framework, SQLx for async database access, and modern Rust idioms.
+
+### Trigger Conditions
+- Writing systems-level code requiring memory safety and zero-cost abstractions.
+- Building high-performance HTTP APIs with **Axum 0.8**.
+- Implementing async services with **Tokio** runtime.
+- Interacting with databases using **SQLx** or **SeaORM**.
+- Building CLI tools with **Clap v4**.
+- Compiling to **WebAssembly (WASM)** for browser or edge deployment.
+- Writing Rust for **Tauri v2** desktop application backends.
+
+### Rust 2024 Edition Highlights
+The Rust 2024 edition (stabilized in 1.85) introduces:
+- **`gen` blocks**: Generators for lazy sequence production.
+- **Lifetime capture rules**: More precise lifetime inference in `impl Trait`.
+- **Unsafe extern blocks**: Clearer unsafe boundary declarations.
+- **`if let` chains**: `if let Some(x) = opt && x > 0` now works cleanly.
+- **`async fn` in traits**: Now stable — no more `async-trait` macro needed.
+
+### Async `fn` in Traits (Stable in Rust 2024)
+```rust
+// No longer need #[async_trait] macro!
+trait DataStore {
+    async fn get(&self, id: &str) -> Result<Data, Error>;
+    async fn set(&self, id: &str, data: Data) -> Result<(), Error>;
+}
+
+impl DataStore for PostgresStore {
+    async fn get(&self, id: &str) -> Result<Data, Error> {
+        sqlx::query_as("SELECT * FROM data WHERE id = $1")
+            .bind(id)
+            .fetch_one(&self.pool)
+            .await
+            .map_err(Into::into)
+    }
+    async fn set(&self, id: &str, data: Data) -> Result<(), Error> {
+        sqlx::query("INSERT INTO data (id, value) VALUES ($1, $2) ON CONFLICT (id) DO UPDATE SET value = $2")
+            .bind(id)
+            .bind(&data.value)
+            .execute(&self.pool)
+            .await?;
+        Ok(())
+    }
+}
+```
+
+### Axum 0.8 — HTTP API Framework
+```rust
+use axum::{
+    extract::{Path, State},
+    response::Json,
+    routing::{get, post},
+    Router,
+};
+use sqlx::PgPool;
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone)]
+struct AppState {
+    db: PgPool,
+}
+
+#[derive(Serialize, Deserialize)]
+struct User {
+    id: String,
+    name: String,
+    email: String,
+}
+
+async fn get_user(
+    Path(user_id): Path<String>,
+    State(state): State<AppState>,
+) -> Result<Json<User>, StatusCode> {
+    let user = sqlx::query_as!(User, "SELECT * FROM users WHERE id = $1", user_id)
+        .fetch_optional(&state.db)
+        .await
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?
+        .ok_or(StatusCode::NOT_FOUND)?;
+
+    Ok(Json(user))
+}
+
+#[tokio::main]
+async fn main() {
+    let db = PgPool::connect(&std::env::var("DATABASE_URL").unwrap())
+        .await
+        .expect("Failed to connect to database");
+
+    let state = AppState { db };
+
+    let app = Router::new()
+        .route("/users/:id", get(get_user))
+        .route("/users", post(create_user))
+        .with_state(state);
+
+    let listener = tokio::net::TcpListener::bind("0.0.0.0:8080").await.unwrap();
+    println!("Listening on :8080");
+    axum::serve(listener, app).await.unwrap();
+}
+```
+
+### SQLx — Compile-Time Verified SQL
+```rust
+// Compile-time SQL checking (requires DATABASE_URL at build time)
+let users = sqlx::query_as!(
+    User,
+    r#"SELECT id, name, email FROM users WHERE created_at > $1 ORDER BY created_at DESC LIMIT $2"#,
+    since,
+    limit as i64
+)
+.fetch_all(&pool)
+.await?;
+```
+
+### Error Handling — thiserror + anyhow
+```rust
+use thiserror::Error;
+
+// Library errors: use thiserror for typed errors
+#[derive(Debug, Error)]
+pub enum AppError {
+    #[error("User not found: {id}")]
+    UserNotFound { id: String },
+    #[error("Database error: {0}")]
+    Database(#[from] sqlx::Error),
+    #[error("Validation failed: {message}")]
+    Validation { message: String },
+}
+
+// Application code: use anyhow for ergonomic error propagation
+use anyhow::{Context, Result};
+
+fn process() -> Result<()> {
+    let config = load_config().context("Failed to load configuration")?;
+    let db = connect_db(&config).context("Failed to connect to database")?;
+    Ok(())
+}
+```
+
+### CLI Tools with Clap v4
+```rust
+use clap::{Parser, Subcommand};
+
+#[derive(Parser)]
+#[command(name = "myapp", version, about = "My CLI tool")]
+struct Cli {
+    #[command(subcommand)]
+    command: Commands,
+}
+
+#[derive(Subcommand)]
+enum Commands {
+    /// Start the server
+    Serve {
+        #[arg(short, long, default_value = "8080")]
+        port: u16,
+    },
+    /// Run migrations
+    Migrate,
+}
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let cli = Cli::parse();
+    match cli.command {
+        Commands::Serve { port } => serve(port).await,
+        Commands::Migrate => run_migrations().await,
+    }
+}
+```
+
+### Performance Best Practices
+- **Zero-cost abstractions**: Use iterators (`map`, `filter`, `collect`) — compiled to the same code as hand-written loops.
+- **Avoid unnecessary cloning**: Use references (`&T`) and lifetimes where possible.
+- **`Arc<T>` for shared state**: Use `Arc<Mutex<T>>` or `Arc<RwLock<T>>` for shared mutable state across threads.
+- **SIMD**: Use `std::simd` (stable in 1.88) for data-parallel operations.
+- **Profile before optimizing**: Use `cargo flamegraph` or `perf` to find actual bottlenecks.
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Deskripsi
+Pengembangan Rust tingkat ahli untuk membangun sistem, API, CLI tool, dan WebAssembly yang aman di memori dan berkinerja tinggi. Mencakup **edisi Rust 2024**, async/await dengan Tokio, framework web Axum 0.8, SQLx untuk akses database async, dan idiom Rust modern.
+
+### Kondisi Pemicu
+- Menulis kode sistem yang membutuhkan keamanan memori dan zero-cost abstraction.
+- Membangun HTTP API berkinerja tinggi dengan **Axum 0.8**.
+- Mengimplementasikan layanan async dengan runtime **Tokio**.
+- Berinteraksi dengan database menggunakan **SQLx** atau SeaORM.
+- Membangun CLI tool dengan **Clap v4**.
+- Mengkompilasi ke **WebAssembly (WASM)** untuk browser atau edge.
+- Menulis backend Rust untuk aplikasi desktop **Tauri v2**.
+
+### Sorotan Edisi Rust 2024
+- **`async fn` dalam trait**: Kini stabil — tidak perlu lagi macro `#[async_trait]`.
+- **`if let` chains**: `if let Some(x) = opt && x > 0` kini berfungsi secara bersih.
+- **`gen` blocks**: Generator untuk produksi urutan yang malas.
+- **Aturan lifetime capture**: Inferensi lifetime yang lebih presisi di `impl Trait`.
+
+### Axum 0.8 — Framework HTTP API
+Gunakan Axum untuk HTTP API yang idiomatis dan berkinerja tinggi dibangun di atas Tokio. Manfaatkan extractor (`Path`, `State`, `Json`, `Query`) untuk parameter handler yang type-safe.
+
+### SQLx — SQL Terverifikasi Waktu Kompilasi
+SQLx memverifikasi query SQL Anda terhadap database nyata saat kompilasi — menghilangkan seluruh kelas bug runtime.
+
+### Penanganan Error — thiserror + anyhow
+- Gunakan `thiserror` untuk error bertipe di library code.
+- Gunakan `anyhow` untuk propagasi error yang ergonomis di application code.
+
+### CLI Tool dengan Clap v4
+Clap v4 menggunakan derive macro untuk mendefinisikan antarmuka CLI secara deklaratif — perintah, subperintah, argumen, dan flag dengan parsing bawaan.
+
+### Praktik Terbaik Performa
+- Gunakan iterator (`map`, `filter`, `collect`) — dikompilasi setara dengan loop manual.
+- Hindari cloning yang tidak perlu — gunakan referensi dan lifetime.
+- Gunakan `Arc<Mutex<T>>` untuk state bersama yang dapat dimutasi di antara thread.
+- Profiling terlebih dahulu dengan `cargo flamegraph` sebelum mengoptimalkan.