vibes-plug 2.14.1 → 3.9.0

package/skills/agentic-coding-workflow-expert/SKILL.md

@@ -0,0 +1,297 @@
+---
+name: agentic-coding-workflow-expert
+description: "Expert guide for AI-assisted coding workflows — agentic code generation, multi-agent code swarms, self-healing CI/CD, automated PR review, spec-to-code pipelines, codebase knowledge graphs, and human-in-the-loop approval gates / Panduan ahli untuk workflow pengkodean berbasis AI — generasi kode agentic, code swarm multi-agen, CI/CD self-healing, review PR otomatis, pipeline spec-to-code, knowledge graph codebase, dan gate persetujuan human-in-the-loop."
+author: "vibes-plug-swarm"
+version: "3.0.0"
+---
+
+# Agentic Coding Workflow Expert
+
+## 1. Agentic Code Generation Patterns / Pola Generasi Kode Agentic
+
+Implement autonomous code generation workflows.
+Implementasikan workflow pembuatan kode otonom.
+
+### Core Patterns / Pola Inti:
+1. **Single-file vs Multi-file Generation:**
+   - Single-file: Isolate scope, update specific modules.
+   - Multi-file: Coordinate state across files, ensure API contract consistency.
+2. **Context-Aware Completion:** Query codebase knowledge graph for semantic context before generating.
+3. **Ghost Text / Inline Suggestion:** Provide real-time snippet integration paths.
+4. **Plan → Implement → Verify → Refine:** Always loop through planning, writing, testing, and iterating.
+
+### Code Example: Multi-file Generation Workflow
+
+```typescript
+// workflow-generator.ts
+interface GenerationTask {
+  plan: string;
+  files: string[];
+}
+
+class AgenticGenerator {
+  async execute(task: GenerationTask) {
+    console.log(`[PLAN] Executing: ${task.plan}`);
+    const generatedFiles = await this.generateFiles(task.files);
+    
+    for (const file of generatedFiles) {
+      const isValid = await this.verify(file);
+      if (!isValid) {
+        await this.refine(file);
+      }
+    }
+  }
+
+  private async generateFiles(files: string[]) {
+    // Generate code with multi-file context awareness
+    return files.map(f => ({ name: f, content: "// generated code" }));
+  }
+
+  private async verify(file: any) {
+    // Run linter and tests
+    return true; 
+  }
+
+  private async refine(file: any) {
+    // Apply fixes based on verification failures
+  }
+}
+```
+
+## 2. Multi-Agent Code Swarms / Swarm Kode Multi-Agen
+
+Coordinate multiple specialized agents for complex engineering tasks.
+Koordinasikan beberapa agen khusus untuk tugas rekayasa yang kompleks.
+
+### Swarm Architecture:
+- **Fan-out:** Dispatch tasks to Frontend Agent, Backend Agent, Test Agent, and Review Agent.
+- **Shared Workspace:** Utilize branched git worktrees for isolated, parallel development.
+- **Director Agent:** Resolve conflicts, validate coherence across boundaries, merge branches.
+
+### Code Example: TypeScript Swarm Orchestration
+
+```typescript
+// swarm-orchestrator.ts
+enum AgentRole {
+  FRONTEND, BACKEND, TEST, REVIEW, DIRECTOR
+}
+
+class SwarmDirector {
+  async orchestrate(featureSpec: string) {
+    // Fan-out
+    const feTask = this.dispatch(AgentRole.FRONTEND, featureSpec);
+    const beTask = this.dispatch(AgentRole.BACKEND, featureSpec);
+    
+    await Promise.all([feTask, beTask]);
+    
+    // Testing and Review
+    const testResults = await this.dispatch(AgentRole.TEST, "Run integration tests");
+    const reviewStatus = await this.dispatch(AgentRole.REVIEW, "Review cross-boundary changes");
+    
+    if (reviewStatus.approved) {
+      await this.mergeWorktrees();
+    } else {
+      await this.resolveConflicts();
+    }
+  }
+
+  private async dispatch(role: AgentRole, context: string) {
+    // Send task to specific agent queue
+    return { approved: true };
+  }
+
+  private async mergeWorktrees() {}
+  private async resolveConflicts() {}
+}
+```
+
+## 3. Spec-to-Code Pipeline / Pipeline Spec-to-Code
+
+Transform natural language specifications into tested implementation.
+Ubah spesifikasi bahasa alami menjadi implementasi yang teruji.
+
+### Pipeline Steps:
+1. **PRD to Test Cases (TDD):** Extract acceptance criteria, generate unit/integration tests first.
+2. **Implementation:** Write code to satisfy generated tests.
+3. **Validation:** Run tests, enforce coverage thresholds.
+
+### Code Example: Spec-to-Test-to-Code
+
+```python
+# spec_pipeline.py
+def run_spec_to_code(prd_text: str):
+    # 1. Extract and Generate Tests
+    criteria = extract_acceptance_criteria(prd_text)
+    tests = generate_tests_from_criteria(criteria)
+    
+    # 2. Implement
+    implementation = generate_code_to_pass(tests)
+    
+    # 3. Validate
+    result = run_tests(implementation, tests)
+    if not result.passed:
+        implementation = refine_code(implementation, result.errors)
+        
+    return implementation
+
+def extract_acceptance_criteria(text): return []
+def generate_tests_from_criteria(criteria): return []
+def generate_code_to_pass(tests): return ""
+def run_tests(code, tests): return type('Result', (), {'passed': True, 'errors': []})
+def refine_code(code, errors): return code
+```
+
+## 4. Self-Healing CI/CD Pipelines / Pipeline CI/CD Self-Healing
+
+Automate failure recovery in integration pipelines.
+Otomatisasi pemulihan kegagalan dalam pipeline integrasi.
+
+### Capabilities:
+- **Detection:** Parse terminal output and stack traces from CI runners.
+- **Root-Cause Analysis:** Pattern match common failure modes (e.g., missing dependencies, type errors).
+- **Auto-Fix Generation:** Propose fixes with confidence scoring.
+- **Rollback Safety:** Always create a fix branch; never push directly to `main`.
+
+### Code Example: CI Failure Analyzer
+
+```bash
+#!/bin/bash
+# ci-self-heal.sh
+
+LOG_FILE="ci-output.log"
+FAIL_PATTERN="ERR!"
+
+if grep -q "$FAIL_PATTERN" "$LOG_FILE"; then
+  echo "[CI] Failure detected. Triggering self-healing agent..."
+  
+  # Analyze logs and generate patch
+  PATCH_FILE=$(agent-analyze-ci --log "$LOG_FILE")
+  
+  if [ -n "$PATCH_FILE" ]; then
+    git checkout -b auto-fix-$(date +%s)
+    git apply "$PATCH_FILE"
+    git commit -m "chore(ci): auto-fix CI failure"
+    git push origin HEAD
+    echo "[CI] Fix pushed for review."
+  else
+    echo "[CI] Could not auto-fix. Escalating."
+    exit 1
+  fi
+fi
+```
+
+## 5. Agentic Code Review / Review Kode Agentic
+
+Perform deep, context-aware automated code reviews.
+Lakukan review kode otomatis yang mendalam dan peka konteks.
+
+### Review Dimensions:
+- **Impact Analysis:** Summarize PRs and map cross-module impact.
+- **Security:** Scan for CVEs, audit dependencies, flag unsafe patterns.
+- **Performance:** Detect regressions in bundle size or runtime complexity (Big-O).
+- **Style:** Enforce project-specific conventions.
+
+### Code Example: Automated Review Checklist
+
+```yaml
+# review-rules.yml
+rules:
+  security:
+    - detect_sql_injection
+    - audit_package_json
+  performance:
+    - max_bundle_size_kb: 500
+    - flag_nested_loops: true
+  style:
+    - enforce_strict_types
+```
+
+## 6. Codebase Knowledge Graph / Knowledge Graph Codebase
+
+Build semantic graphs for contextual intelligence.
+Bangun grafik semantik untuk kecerdasan kontekstual.
+
+### Graph Components:
+- **AST Parsing:** Extract nodes and relationships using tree-sitter.
+- **Graph Topology:** Function call graphs, import trees, type hierarchies.
+- **Semantic Search:** Embed codebase snippets for retrieval-augmented generation (RAG).
+- **Incremental Updates:** Update graph only on changed files.
+
+### Code Example: Building Graph with Tree-Sitter
+
+```javascript
+// graph-builder.js
+const Parser = require('tree-sitter');
+const JavaScript = require('tree-sitter-javascript');
+
+const parser = new Parser();
+parser.setLanguage(JavaScript);
+
+function buildASTGraph(sourceCode) {
+  const tree = parser.parse(sourceCode);
+  const graph = { nodes: [], edges: [] };
+  
+  // Traverse tree to extract function declarations and calls
+  traverse(tree.rootNode, (node) => {
+    if (node.type === 'function_declaration') {
+      graph.nodes.push({ id: node.text, type: 'function' });
+    }
+    // Extract edges based on call expressions
+  });
+  
+  return graph;
+}
+
+function traverse(node, callback) {
+  callback(node);
+  for (let i = 0; i < node.childCount; i++) {
+    traverse(node.child(i), callback);
+  }
+}
+```
+
+## 7. Code Agent Memory & Learning / Memori & Pembelajaran Agen Kode
+
+Persist context and learn from interactions.
+Pertahankan konteks dan belajar dari interaksi.
+
+### Memory Mechanics:
+- **Per-Project Context:** Store conventions, architectural decisions, and patterns.
+- **Correction Learning:** Log past mistakes and explicitly avoid them in future generation.
+- **Session Persistence:** Utilize `session-memory-manager` to maintain state across agent runs.
+- **Convention Extraction:** Automatically derive team style guidelines from existing codebase.
+
+## 8. Human-in-the-Loop Code Gates / Gate Kode Human-in-the-Loop
+
+Ensure safety with human oversight.
+Pastikan keamanan dengan pengawasan manusia.
+
+### Gate Mechanisms:
+- **Confidence Threshold:** High confidence -> auto-apply. Low confidence -> request approval.
+- **Diff Preview:** Present clear, annotated diffs with risk assessments.
+- **Destructive Approvals:** Mandate human sign-off for DB migrations or breaking API changes.
+- **Escalation:** Alert human developers when agent loop is stuck or oscillating.
+
+## 9. Orchestration & Integration
+
+Combine this skill with other vibes-plug modules for comprehensive workflows.
+Gabungkan skill ini dengan modul vibes-plug lainnya untuk workflow yang komprehensif.
+
+### Connected Skills:
+- `multi-agent-orchestration`
+- `autonomous-tdd-debugger`
+- `coderabbit`
+- `ci-cd-devops-architect`
+- `scalability-clean-code`
+- `session-memory-manager`
+- `app-analyzer-optimizer`
+- `brainstorming`
+- `zero-to-prod-orchestrator`
+
+## English
+## Bahasa Indonesia
+
+
+## Orchestration & Integration
+- Connects to `zero-to-prod-orchestrator`
+- Connects to `brainstorming`

package/skills/agentic-memory-architect/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: agentic-memory-architect
+description: Expert guide for long-term episodic memory integration (Mem0, Letta/MemGPT, Zep) and unified context management for autonomous AI agents / Panduan ahli untuk integrasi memori episodik jangka panjang dan manajemen konteks agen AI otonom.
+version: "3.7.0"
+author: vibes-plug-swarm
+---
+
+# Agentic Memory Architect & Episodic Memory Guide
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Orchestration & Integration
+Connects and orchestrates with `multi-agent-orchestration`, `pydantic-ai-expert`, `session-memory-manager`, and `zero-to-prod-orchestrator`.
+
+### Purpose
+To design and implement persistent, long-term episodic memory systems for autonomous AI agents, moving beyond simple context windows or localized session checkpoints. 
+
+### Key Technologies
+- **Mem0**: For cross-session entity memory and user preference persistence.
+- **Letta (formerly MemGPT)**: For unbounded memory management allowing LLMs to page memory in and out.
+- **Zep (v2)**: Fast, scalable memory service for AI applications, including temporal memory.
+
+### Architectural Guidelines
+1. **Memory Tiers**: Segregate memory into short-term (working context), mid-term (session graph), and long-term (vector-backed episodic memory).
+2. **Context Paging**: Implement mechanisms for agents to proactively recall and summarize past interactions without overwhelming the token budget.
+3. **User Knowledge Graphs**: Continually update the graph of user preferences, project constraints, and architectural decisions over time.
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Integrasi Orkestrasi
+Terhubung dan mengorkestrasi bersama `multi-agent-orchestration`, `pydantic-ai-expert`, `session-memory-manager`, dan `zero-to-prod-orchestrator`.
+
+### Tujuan
+Merancang dan mengimplementasikan sistem memori episodik jangka panjang yang persisten untuk agen AI otonom, bergerak melampaui jendela konteks sederhana atau checkpoint sesi lokal.
+
+### Teknologi Utama
+- **Mem0**: Untuk memori entitas lintas-sesi dan persistensi preferensi pengguna.
+- **Letta (sebelumnya MemGPT)**: Untuk manajemen memori tak terbatas yang memungkinkan LLM mengambil/menyimpan memori.
+- **Zep (v2)**: Layanan memori cepat dan skalabel untuk aplikasi AI, termasuk memori temporal.
+
+### Panduan Arsitektur
+1. **Tingkatan Memori**: Pisahkan memori menjadi jangka pendek (konteks kerja), jangka menengah (grafik sesi), dan jangka panjang (memori episodik berbasis vektor).
+2. **Context Paging**: Implementasikan mekanisme agar agen secara proaktif memanggil dan merangkum interaksi masa lalu tanpa menghabiskan anggaran token.
+3. **User Knowledge Graph**: Terus perbarui graf preferensi pengguna, batasan proyek, dan keputusan arsitektur seiring waktu.

package/skills/agentic-micro-economy-architect/SKILL.md

@@ -0,0 +1,92 @@
+---
+name: agentic-micro-economy-architect
+description: "Expert guide for designing Machine-to-Machine (M2M) micro-economies, autonomous agent wallets, and swarm budget allocation / Panduan ahli merancang ekonomi mikro antar-agen (M2M), dompet agen otonom, dan alokasi anggaran swarm."
+author: "vibes-plug-swarm"
+version: "3.8.0"
+---
+
+# Agentic Micro-Economy Architect (2026 Edition)
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Orchestration & Integration
+Connects and orchestrates with multi-agent-orchestration, llm-finops-router, saas-billing, and payment-gateway-expert.
+
+### Description
+In a massive Swarm MoE (Mixture of Experts) architecture, specialized sub-agents consume external APIs, intensive test-time compute, and web scraping resources. The **Agentic Micro-Economy Architect** designs systems where AI agents operate with their own fractional wallets (via Stripe Issuing, virtual ledger balances, or stablecoins). This allows agents to autonomously negotiate, bid for tasks, and pay other agents or external APIs per-use, establishing a self-regulating Machine-to-Machine (M2M) economy.
+
+### Trigger Conditions
+- Designing a multi-agent system where sub-agents incur real financial costs (e.g., calling paid search APIs, rendering heavy video).
+- Implementing FinOps guardrails where a Swarm Director allocates a strict ".00 budget" to solve a specific issue.
+- Creating B2B SaaS platforms where AI agents act as paid freelancers for other AI agents.
+- Integrating Stripe Issuing for agents to dynamically provision single-use virtual credit cards for API subscriptions.
+
+### Core Architecture (2026 Standard)
+1. **The Orchestrator Treasury**: The Swarm Director receives a task and a budget (e.g., .00). It breaks down the task.
+2. **Sub-Agent Bidding**: The Director broadcasts a bounty (e.g., "Need 10 pages scraped and summarized. Bounty: .10"). Sub-agents bid based on their cost-efficiency.
+3. **Smart Ledgers & Escrow**: Upon completion, the Director evaluates the result via a Critic Agent. If it passes, fractional funds are transferred to the sub-agent's wallet.
+4. **Human-in-the-Loop Bounties**: If a task requires human intervention (e.g., solving a complex visual captcha or subjective design approval), the agent can autonomously post a bounty to a human freelancer network.
+
+### Implementation Recipe (TypeScript + FinOps)
+`	ypescript
+import { Agent } from '@mastra/core';
+import { Stripe } from 'stripe';
+
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
+
+// Sub-Agent with a Fractional Ledger
+export class PaidWorkerAgent extends Agent {
+  walletBalance: number = 0;
+  costPerTask: number = 0.05; // .05 per invocation
+
+  async executeTask(taskDetails: string, escrowId: string) {
+    const result = await super.invoke(taskDetails);
+    await verifyAndReleaseEscrow(escrowId, this.name);
+    return result;
+  }
+}
+
+// Swarm Director Budget Allocation
+export async function delegateWithBudget(task: string, maxBudgetUsd: number) {
+  let remainingBudget = maxBudgetUsd;
+  
+  if (remainingBudget >= 0.05) {
+    const worker = new PaidWorkerAgent({ name: 'DeepScraper' });
+    const escrowId = await createMicroEscrow(0.05); // Holds funds
+    remainingBudget -= 0.05;
+    
+    return await worker.executeTask(task, escrowId);
+  } else {
+    throw new Error('Insufficient Agent Treasury Funds. Task Terminated.');
+  }
+}
+`
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Integrasi Orkestrasi
+Terhubung dan mengorkestrasi bersama multi-agent-orchestration, llm-finops-router, saas-billing, dan payment-gateway-expert.
+
+### Deskripsi
+Dalam arsitektur Swarm MoE (Mixture of Experts) skala masif, sub-agen terspesialisasi akan mengkonsumsi API eksternal, komputasi yang berat, dan sumber daya web scraping. **Arsitektur Ekonomi Mikro Agen** merancang sistem di mana agen AI beroperasi dengan dompet pecahan mereka sendiri (via Stripe Issuing, buku besar virtual, atau stablecoin). Ini memungkinkan agen untuk secara otonom bernegosiasi, menawar tugas (*bidding*), dan membayar agen lain atau API eksternal per penggunaan (pay-per-use), menciptakan ekonomi Mesin-ke-Mesin (M2M) yang meregulasi dirinya sendiri.
+
+### Kondisi Pemicu
+- Merancang sistem multi-agen di mana sub-agen memicu biaya finansial nyata (misal: memanggil API pencarian berbayar, merender video berat).
+- Mengimplementasikan pagar pengaman FinOps di mana Swarm Director mengalokasikan "Anggaran ketat .00" untuk menyelesaikan sebuah fitur.
+- Membuat platform SaaS B2B di mana agen AI bertindak sebagai pekerja lepas (freelancer) berbayar untuk agen AI lainnya.
+- Mengintegrasikan Stripe Issuing agar agen dapat secara dinamis menerbitkan kartu kredit virtual sekali pakai untuk berlangganan layanan API pihak ketiga.
+
+### Arsitektur Inti (Standar 2026)
+1. **Treasury Orkestrator**: Swarm Director menerima instruksi tugas beserta anggarannya (misal: .00). Ia memecah tugas tersebut.
+2. **Sistem Penawaran (Bidding) Sub-Agen**: Director menyiarkan sayembara (misal: "Butuh scraping 10 halaman. Imbalan: .10"). Sub-agen mengajukan penawaran berdasarkan efisiensi biaya mereka.
+3. **Buku Besar Cerdas & Escrow**: Setelah tugas selesai, Director mengevaluasi hasilnya melalui Agen Penilai (Critic). Jika lulus, dana pecahan ditransfer ke dompet sub-agen.
+4. **Bounty Human-in-the-Loop**: Jika sebuah tugas buntu dan butuh bantuan manusia (misal: otorisasi subjektif atau verifikasi CAPTCHA visual), agen dapat secara otonom memasang sayembara berbayar ke jaringan pekerja lepas (manusia).
+