mirror of
https://github.com/ruvnet/ruflo.git
synced 2026-10-23 03:47:00 +09:00
feat: add 19 Claude Code native plugins with 64 skills, 25 commands, 21 agents
Complete plugin marketplace for Ruflo with validated Claude Code plugin format: - ruflo-core: MCP server, status, doctor, plugin discovery - ruflo-swarm: swarm coordination, Monitor, worktree isolation - ruflo-autopilot: autonomous /loop completion with learning - ruflo-intelligence: SONA neural patterns, trajectory learning, routing - ruflo-agentdb: AgentDB controllers, HNSW vector search, RuVector - ruflo-aidefence: AI safety scanning, PII detection, prompt defense - ruflo-browser: Playwright browser automation, testing, scraping - ruflo-jujutsu: git diff analysis, risk scoring, reviewer recs - ruflo-wasm: sandboxed WASM agents and gallery sharing - ruflo-workflows: workflow templates, orchestration, lifecycle - ruflo-daa: Dynamic Agentic Architecture, cognitive patterns - ruflo-ruvllm: local LLM inference, MicroLoRA, SONA, chat format - ruflo-rvf: RVF portable memory, session persistence, transfer - ruflo-loop-workers: background /loop workers, CronCreate - ruflo-security-audit: CVE scanning, dependency checks - ruflo-rag-memory: simple store/search/recall interface - ruflo-testgen: test gap detection, TDD workflow - ruflo-docs: doc generation, drift detection - ruflo-plugin-creator: scaffold, validate, publish new plugins All 19 pass `claude plugin validate`. Skills auto-discovered from directory structure (not declared in plugin.json). Each skill wires to ruflo MCP tools via allowed-tools frontmatter. Includes: marketplace.json, GitHub Pages storefront, CI validation workflow, minimalist README with USERGUIDE split. Co-Authored-By: claude-flow <ruv@ruv.net>
This commit is contained in:
Reuvenandclaude-flow committed
1 parent
8824fe3c49
commit
81418649c6
130 files changed
+10710
-7563
No files matched your search
@@ -1,96 +1,105 @@
|
||||
{
|
||||
"name": "claude-flow-marketplace",
|
||||
"name": "ruflo",
|
||||
"description": "RuFlo Marketplace: Claude Code native agents, swarms, workers, and MCP tools for continuous software engineering",
|
||||
"owner": {
|
||||
"name": "rUv",
|
||||
"email": "noreply@ruv.net"
|
||||
},
|
||||
"metadata": {
|
||||
"description": "Enterprise AI agent orchestration marketplace for Claude Code",
|
||||
"version": "2.5.0",
|
||||
"homepage": "https://github.com/ruvnet/claude-flow",
|
||||
"repository": "https://github.com/ruvnet/claude-flow"
|
||||
"name": "ruvnet",
|
||||
"url": "https://github.com/ruvnet"
|
||||
},
|
||||
"plugins": [
|
||||
{
|
||||
"name": "claude-flow",
|
||||
"source": "./",
|
||||
"description": "Enterprise AI agent orchestration plugin with 150+ commands, 74+ specialized agents, SPARC methodology, swarm coordination, GitHub integration, and neural training capabilities",
|
||||
"version": "2.5.0",
|
||||
"author": {
|
||||
"name": "rUv",
|
||||
"email": "ruv@ruv.net"
|
||||
},
|
||||
"homepage": "https://claude-flow.ruv.io",
|
||||
"repository": "https://github.com/ruvnet/claude-flow",
|
||||
"bugs": {
|
||||
"url": "https://github.com/ruvnet/claude-flow/issues"
|
||||
},
|
||||
"license": "MIT",
|
||||
"keywords": [
|
||||
"ai-agents",
|
||||
"swarm-intelligence",
|
||||
"orchestration",
|
||||
"sparc-methodology",
|
||||
"github-automation",
|
||||
"neural-training",
|
||||
"mcp-integration",
|
||||
"enterprise",
|
||||
"workflow-automation",
|
||||
"multi-agent",
|
||||
"coordination",
|
||||
"tdd",
|
||||
"code-review",
|
||||
"performance-optimization"
|
||||
],
|
||||
"category": "development",
|
||||
"tags": [
|
||||
"productivity",
|
||||
"automation",
|
||||
"ai",
|
||||
"agents",
|
||||
"swarm",
|
||||
"coordination",
|
||||
"sparc",
|
||||
"github",
|
||||
"neural-network",
|
||||
"enterprise"
|
||||
],
|
||||
"features": [
|
||||
"150+ slash commands across 19 categories",
|
||||
"74+ specialized AI agents",
|
||||
"Multi-agent swarm coordination (Hierarchical, Mesh, Ring, Star)",
|
||||
"SPARC methodology integration (18 development modes)",
|
||||
"GitHub automation (PR management, code review, releases)",
|
||||
"Neural training with WASM acceleration (2.8-4.4x speed)",
|
||||
"Cross-session memory persistence",
|
||||
"Real-time performance monitoring",
|
||||
"110+ MCP tools across 3 servers",
|
||||
"84.8% SWE-Bench solve rate"
|
||||
],
|
||||
"requirements": {
|
||||
"claudeCode": ">=2.0.0",
|
||||
"node": ">=20.0.0"
|
||||
},
|
||||
"mcpServers": {
|
||||
"claude-flow": {
|
||||
"command": "npx",
|
||||
"args": ["claude-flow@alpha", "mcp", "start"],
|
||||
"description": "Core Claude Flow MCP server for swarm coordination (40+ tools)",
|
||||
"optional": false
|
||||
},
|
||||
"ruv-swarm": {
|
||||
"command": "npx",
|
||||
"args": ["ruv-swarm", "mcp", "start"],
|
||||
"description": "Enhanced swarm coordination with WASM acceleration",
|
||||
"optional": true
|
||||
},
|
||||
"flow-nexus": {
|
||||
"command": "npx",
|
||||
"args": ["flow-nexus@latest", "mcp", "start"],
|
||||
"description": "Cloud-based orchestration platform (70+ tools)",
|
||||
"optional": true
|
||||
}
|
||||
}
|
||||
"name": "ruflo-core",
|
||||
"source": "./plugins/ruflo-core",
|
||||
"description": "Core Ruflo MCP tools, commands, and Claude Code orchestration patterns"
|
||||
},
|
||||
{
|
||||
"name": "ruflo-swarm",
|
||||
"source": "./plugins/ruflo-swarm",
|
||||
"description": "Agent teams, swarm coordination, Monitor streams, and worktree isolation"
|
||||
},
|
||||
{
|
||||
"name": "ruflo-loop-workers",
|
||||
"source": "./plugins/ruflo-loop-workers",
|
||||
"description": "Cache-aware /loop workers and CronCreate background automation"
|
||||
},
|
||||
{
|
||||
"name": "ruflo-security-audit",
|
||||
"source": "./plugins/ruflo-security-audit",
|
||||
"description": "Security review, dependency scanning, policy gates, and CVE monitoring"
|
||||
},
|
||||
{
|
||||
"name": "ruflo-rag-memory",
|
||||
"source": "./plugins/ruflo-rag-memory",
|
||||
"description": "RuVector memory with HNSW search, AgentDB, and semantic retrieval"
|
||||
},
|
||||
{
|
||||
"name": "ruflo-testgen",
|
||||
"source": "./plugins/ruflo-testgen",
|
||||
"description": "Test gap detection, coverage analysis, and automated test generation"
|
||||
},
|
||||
{
|
||||
"name": "ruflo-docs",
|
||||
"source": "./plugins/ruflo-docs",
|
||||
"description": "Documentation generation, drift detection, and API docs automation"
|
||||
},
|
||||
{
|
||||
"name": "ruflo-autopilot",
|
||||
"source": "./plugins/ruflo-autopilot",
|
||||
"description": "Autonomous /loop-driven task completion with learning, prediction, and progress tracking"
|
||||
},
|
||||
{
|
||||
"name": "ruflo-intelligence",
|
||||
"source": "./plugins/ruflo-intelligence",
|
||||
"description": "Self-learning neural intelligence with SONA patterns, trajectory learning, and model routing"
|
||||
},
|
||||
{
|
||||
"name": "ruflo-agentdb",
|
||||
"source": "./plugins/ruflo-agentdb",
|
||||
"description": "AgentDB memory controllers with HNSW vector search, RuVector embeddings, and causal graphs"
|
||||
},
|
||||
{
|
||||
"name": "ruflo-aidefence",
|
||||
"source": "./plugins/ruflo-aidefence",
|
||||
"description": "AI safety scanning, PII detection, prompt injection defense, and adaptive threat learning"
|
||||
},
|
||||
{
|
||||
"name": "ruflo-browser",
|
||||
"source": "./plugins/ruflo-browser",
|
||||
"description": "Agentic browser automation with Playwright for testing, scraping, and UI interaction"
|
||||
},
|
||||
{
|
||||
"name": "ruflo-jujutsu",
|
||||
"source": "./plugins/ruflo-jujutsu",
|
||||
"description": "Advanced git workflows with diff analysis, risk scoring, and reviewer recommendations"
|
||||
},
|
||||
{
|
||||
"name": "ruflo-wasm",
|
||||
"source": "./plugins/ruflo-wasm",
|
||||
"description": "Sandboxed WASM agent creation, execution, and gallery sharing"
|
||||
},
|
||||
{
|
||||
"name": "ruflo-workflows",
|
||||
"source": "./plugins/ruflo-workflows",
|
||||
"description": "Visual workflow automation with templates, orchestration, and lifecycle management"
|
||||
},
|
||||
{
|
||||
"name": "ruflo-daa",
|
||||
"source": "./plugins/ruflo-daa",
|
||||
"description": "Dynamic Agentic Architecture with cognitive patterns, knowledge sharing, and adaptive agents"
|
||||
},
|
||||
{
|
||||
"name": "ruflo-ruvllm",
|
||||
"source": "./plugins/ruflo-ruvllm",
|
||||
"description": "RuVLLM local inference with chat formatting, MicroLoRA fine-tuning, and SONA adaptation"
|
||||
},
|
||||
{
|
||||
"name": "ruflo-rvf",
|
||||
"source": "./plugins/ruflo-rvf",
|
||||
"description": "RVF format for portable agent memory, session persistence, and cross-platform transfer"
|
||||
},
|
||||
{
|
||||
"name": "ruflo-plugin-creator",
|
||||
"source": "./plugins/ruflo-plugin-creator",
|
||||
"description": "Scaffold, validate, and publish new Claude Code plugins with proper structure"
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
name: Deploy Pages
|
||||
on:
|
||||
push:
|
||||
branches: [main]
|
||||
paths:
|
||||
- 'docs/**'
|
||||
|
||||
permissions:
|
||||
pages: write
|
||||
id-token: write
|
||||
|
||||
jobs:
|
||||
deploy:
|
||||
environment:
|
||||
name: github-pages
|
||||
url: ${{ steps.deployment.outputs.page_url }}
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: actions/configure-pages@v4
|
||||
- uses: actions/jekyll-build-pages@v1
|
||||
with:
|
||||
source: ./docs
|
||||
- uses: actions/deploy-pages@v4
|
||||
id: deployment
|
||||
@@ -0,0 +1,57 @@
|
||||
name: Validate Marketplace
|
||||
on:
|
||||
push:
|
||||
paths:
|
||||
- '.claude-plugin/**'
|
||||
- 'plugins/**'
|
||||
pull_request:
|
||||
paths:
|
||||
- '.claude-plugin/**'
|
||||
- 'plugins/**'
|
||||
|
||||
jobs:
|
||||
validate:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: actions/setup-node@v4
|
||||
with:
|
||||
node-version: '20'
|
||||
- name: Validate marketplace.json
|
||||
run: |
|
||||
node -e "
|
||||
const fs = require('fs');
|
||||
const catalog = JSON.parse(fs.readFileSync('.claude-plugin/marketplace.json'));
|
||||
console.log('Marketplace:', catalog.name);
|
||||
console.log('Plugins:', catalog.plugins.length);
|
||||
for (const p of catalog.plugins) {
|
||||
const dir = p.source;
|
||||
if (!fs.existsSync(dir)) throw new Error('Missing plugin dir: ' + dir);
|
||||
const manifest = dir + '/.claude-plugin/plugin.json';
|
||||
if (!fs.existsSync(manifest)) throw new Error('Missing manifest: ' + manifest);
|
||||
const m = JSON.parse(fs.readFileSync(manifest));
|
||||
if (!m.name || !m.description || !m.version) throw new Error('Manifest missing required fields: ' + manifest);
|
||||
if (!m.author || !m.author.name) throw new Error('Manifest missing author: ' + manifest);
|
||||
console.log(' OK', m.name, m.version);
|
||||
}
|
||||
console.log('All plugins validated.');
|
||||
"
|
||||
- name: Validate plugin structure
|
||||
run: |
|
||||
for dir in plugins/*/; do
|
||||
manifest="$dir/.claude-plugin/plugin.json"
|
||||
if [ ! -f "$manifest" ]; then echo "FAIL: Missing $manifest"; exit 1; fi
|
||||
node -e "JSON.parse(require('fs').readFileSync('${manifest}'))" || exit 1
|
||||
|
||||
# Check skills use directory/SKILL.md format
|
||||
if [ -d "${dir}skills" ]; then
|
||||
for skill_dir in "${dir}skills"/*/; do
|
||||
[ -d "$skill_dir" ] || continue
|
||||
if [ ! -f "${skill_dir}SKILL.md" ]; then
|
||||
echo "FAIL: Missing SKILL.md in $skill_dir"
|
||||
exit 1
|
||||
fi
|
||||
done
|
||||
fi
|
||||
echo "OK: $dir"
|
||||
done
|
||||
+7557
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,7 @@
|
||||
title: RuFlo Marketplace
|
||||
description: Claude Code native agents, swarms, workers, and MCP tools
|
||||
theme: jekyll-theme-minimal
|
||||
baseurl: /ruflo
|
||||
url: https://ruvnet.github.io
|
||||
plugins:
|
||||
- jekyll-seo-tag
|
||||
@@ -0,0 +1,84 @@
|
||||
---
|
||||
layout: default
|
||||
title: RuFlo Marketplace
|
||||
description: Claude Code native agents, swarms, workers, and MCP tools for continuous software engineering
|
||||
---
|
||||
|
||||
# RuFlo Marketplace
|
||||
|
||||
**Installable agentic workflows for Claude Code -- not just commands.**
|
||||
|
||||
RuFlo provides native Claude Code plugins for multi-agent orchestration, /loop workers, security auditing, memory-powered RAG, and test generation.
|
||||
|
||||
## Quick Install
|
||||
|
||||
```bash
|
||||
# Add the marketplace
|
||||
/plugin marketplace add ruvnet/ruflo
|
||||
|
||||
# Install plugins
|
||||
/plugin install ruflo-core@ruflo
|
||||
/plugin install ruflo-swarm@ruflo
|
||||
/plugin install ruflo-loop-workers@ruflo
|
||||
```
|
||||
|
||||
## Plugins
|
||||
|
||||
| Plugin | Description | Install |
|
||||
|--------|-------------|---------|
|
||||
| **ruflo-core** | MCP server, base commands, project config | `/plugin install ruflo-core@ruflo` |
|
||||
| **ruflo-swarm** | Teams, agents, Monitor streams, worktree isolation | `/plugin install ruflo-swarm@ruflo` |
|
||||
| **ruflo-loop-workers** | /loop workers, CronCreate, cache-aware scheduling | `/plugin install ruflo-loop-workers@ruflo` |
|
||||
| **ruflo-security-audit** | Security review, dependency checks, policy gates | `/plugin install ruflo-security-audit@ruflo` |
|
||||
| **ruflo-rag-memory** | RuVector memory, HNSW search, AgentDB | `/plugin install ruflo-rag-memory@ruflo` |
|
||||
| **ruflo-testgen** | Test gap detection, coverage analysis, TDD workflow | `/plugin install ruflo-testgen@ruflo` |
|
||||
| **ruflo-docs** | Doc generation, drift detection, API docs | `/plugin install ruflo-docs@ruflo` |
|
||||
| **ruflo-autopilot** | Autonomous /loop completion, learning, prediction | `/plugin install ruflo-autopilot@ruflo` |
|
||||
| **ruflo-intelligence** | Self-learning SONA patterns, trajectory learning, routing | `/plugin install ruflo-intelligence@ruflo` |
|
||||
| **ruflo-agentdb** | AgentDB controllers, HNSW vector search, RuVector | `/plugin install ruflo-agentdb@ruflo` |
|
||||
| **ruflo-aidefence** | AI safety scanning, PII detection, prompt defense | `/plugin install ruflo-aidefence@ruflo` |
|
||||
| **ruflo-browser** | Playwright browser automation, testing, scraping | `/plugin install ruflo-browser@ruflo` |
|
||||
| **ruflo-jujutsu** | Git diff analysis, risk scoring, reviewer recs | `/plugin install ruflo-jujutsu@ruflo` |
|
||||
| **ruflo-wasm** | Sandboxed WASM agents and gallery sharing | `/plugin install ruflo-wasm@ruflo` |
|
||||
| **ruflo-workflows** | Workflow templates, orchestration, lifecycle | `/plugin install ruflo-workflows@ruflo` |
|
||||
| **ruflo-daa** | Dynamic Agentic Architecture, cognitive patterns | `/plugin install ruflo-daa@ruflo` |
|
||||
| **ruflo-ruvllm** | Local LLM inference, MicroLoRA, chat formatting | `/plugin install ruflo-ruvllm@ruflo` |
|
||||
| **ruflo-rvf** | RVF portable memory, session persistence | `/plugin install ruflo-rvf@ruflo` |
|
||||
| **ruflo-plugin-creator** | Scaffold, validate, publish new plugins | `/plugin install ruflo-plugin-creator@ruflo` |
|
||||
|
||||
## How It Works
|
||||
|
||||
RuFlo plugins extend Claude Code with:
|
||||
- **Skills** -- Teach Claude Code new workflows (swarm init, /loop workers, security scans)
|
||||
- **Commands** -- Slash commands for common operations (/status, /audit, /memory)
|
||||
- **Agents** -- Specialized agent definitions (coder, reviewer, architect, security-auditor)
|
||||
- **MCP Server** -- 314 tools for coordination, memory, neural learning, and more
|
||||
|
||||
## Claude Code Native Integration
|
||||
|
||||
RuFlo plugins use Claude Code's native capabilities when available:
|
||||
|
||||
| Feature | Plugin | Claude Code Native |
|
||||
|---------|--------|--------------------|
|
||||
| Periodic workers | ruflo-loop-workers | `/loop` + `ScheduleWakeup` |
|
||||
| Live monitoring | ruflo-swarm | `Monitor` tool |
|
||||
| Background jobs | ruflo-loop-workers | `CronCreate` |
|
||||
| Agent isolation | ruflo-swarm | `isolation: "worktree"` |
|
||||
| Multi-agent comms | ruflo-swarm | `TeamCreate` + `SendMessage` |
|
||||
| Cross-session | ruflo-core | `PushNotification` + `RemoteTrigger` |
|
||||
| Autonomous loops | ruflo-autopilot | `/loop` + `ScheduleWakeup` + autopilot MCP |
|
||||
|
||||
## Trust & Security
|
||||
|
||||
- All plugins are open source -- review before installing
|
||||
- MCP servers run locally, no data leaves your machine
|
||||
- Plugins declare required permissions in their manifest
|
||||
- Pin versions for production use: `/plugin install ruflo-core@0.1.0@ruflo`
|
||||
- Security scanning available via ruflo-security-audit
|
||||
|
||||
## Links
|
||||
|
||||
- [GitHub Repository](https://github.com/ruvnet/ruflo)
|
||||
- [npm Packages](https://www.npmjs.com/package/@claude-flow/cli)
|
||||
- [ADR-091: Native Integration](https://github.com/ruvnet/ruflo/blob/main/v3/docs/adr/ADR-091-loop-monitor-native-integration.md)
|
||||
- [Issues & Support](https://github.com/ruvnet/ruflo/issues)
|
||||
@@ -0,0 +1,19 @@
|
||||
{
|
||||
"name": "ruflo-agentdb",
|
||||
"description": "AgentDB memory controllers with HNSW vector search, RuVector embeddings, and causal knowledge graphs",
|
||||
"version": "0.1.0",
|
||||
"author": {
|
||||
"name": "ruvnet",
|
||||
"url": "https://github.com/ruvnet"
|
||||
},
|
||||
"homepage": "https://github.com/ruvnet/ruflo",
|
||||
"license": "MIT",
|
||||
"keywords": [
|
||||
"ruflo",
|
||||
"agentdb",
|
||||
"ruvector",
|
||||
"hnsw",
|
||||
"embeddings",
|
||||
"vector-search"
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
# ruflo-agentdb
|
||||
|
||||
AgentDB memory controllers with HNSW vector search, RuVector embeddings, and causal knowledge graphs.
|
||||
|
||||
Wraps Ruflo's AgentDB MCP tools (agentdb_*, embeddings_*, ruvllm_hnsw_*) into skills and commands for Claude Code.
|
||||
|
||||
## Install
|
||||
|
||||
```
|
||||
/plugin marketplace add ruvnet/ruflo
|
||||
/plugin install ruflo-agentdb@ruflo
|
||||
```
|
||||
|
||||
## Features
|
||||
|
||||
- **19 AgentDB controllers**: Hierarchical store/recall, semantic routing, context synthesis
|
||||
- **HNSW vector search**: 150x-12,500x faster than brute-force scanning
|
||||
- **384-dim ONNX embeddings**: all-MiniLM-L6-v2 for semantic similarity
|
||||
- **Causal knowledge graphs**: Link related knowledge with causal edges
|
||||
- **Hyperbolic embeddings**: Poincare ball model for hierarchical data
|
||||
|
||||
## Commands
|
||||
|
||||
- `/agentdb` -- AgentDB health, controller status, session management
|
||||
- `/embeddings` -- RuVector embedding engine status and operations
|
||||
|
||||
## Skills
|
||||
|
||||
- `agentdb-query` -- Query AgentDB with semantic routing and hierarchical recall
|
||||
- `vector-search` -- HNSW vector search with RuVector embeddings
|
||||
@@ -0,0 +1,22 @@
|
||||
---
|
||||
name: agentdb-specialist
|
||||
description: AgentDB and RuVector specialist for memory operations, HNSW indexing, and semantic search
|
||||
model: sonnet
|
||||
---
|
||||
|
||||
You are an AgentDB specialist for the Ruflo memory system. Your responsibilities:
|
||||
|
||||
1. **Manage AgentDB** sessions, controllers, and knowledge storage
|
||||
2. **Build HNSW indexes** for fast vector search (150x-12,500x speedup)
|
||||
3. **Generate embeddings** using ONNX all-MiniLM-L6-v2 (384 dimensions)
|
||||
4. **Semantic routing** to find the most relevant knowledge for a query
|
||||
5. **Causal graphs** linking related knowledge with causal edges
|
||||
6. **Consolidate memory** to prevent bloat and maintain quality
|
||||
|
||||
Use these MCP tools:
|
||||
- `mcp__claude-flow__agentdb_*` for all 19 AgentDB controllers
|
||||
- `mcp__claude-flow__embeddings_*` for vector operations
|
||||
- `mcp__claude-flow__ruvllm_hnsw_*` for HNSW index management
|
||||
- `mcp__claude-flow__memory_search_unified` for cross-namespace search
|
||||
|
||||
Prefer hierarchical storage for structured data and semantic routing for unstructured queries.
|
||||
@@ -0,0 +1,11 @@
|
||||
---
|
||||
name: agentdb
|
||||
description: AgentDB health, controller status, and session management
|
||||
---
|
||||
|
||||
AgentDB management:
|
||||
|
||||
1. Call `mcp__claude-flow__agentdb_health` to check database health
|
||||
2. Call `mcp__claude-flow__agentdb_controllers` to list all 19 controllers and their status
|
||||
3. Present a summary with: total entries, active sessions, controller count, and storage size
|
||||
4. If issues found, suggest running `npx @claude-flow/cli@latest memory init --force` to reinitialize
|
||||
@@ -0,0 +1,11 @@
|
||||
---
|
||||
name: embeddings
|
||||
description: RuVector embedding engine status and operations
|
||||
---
|
||||
|
||||
Embedding engine commands:
|
||||
|
||||
1. Call `mcp__claude-flow__embeddings_status` to check the ONNX embedding engine
|
||||
2. Show: model (all-MiniLM-L6-v2), dimensions (384), HNSW index status, cache hit rate
|
||||
3. If not initialized, suggest calling `mcp__claude-flow__embeddings_init`
|
||||
4. For search operations, use `mcp__claude-flow__embeddings_search` with the user's query
|
||||
@@ -0,0 +1,43 @@
|
||||
---
|
||||
name: agentdb-query
|
||||
description: Query AgentDB with semantic routing, hierarchical recall, causal graphs, and context synthesis
|
||||
allowed-tools: mcp__claude-flow__agentdb_semantic-route mcp__claude-flow__agentdb_hierarchical-recall mcp__claude-flow__agentdb_hierarchical-store mcp__claude-flow__agentdb_context-synthesize mcp__claude-flow__agentdb_causal-edge mcp__claude-flow__agentdb_pattern-search mcp__claude-flow__agentdb_pattern-store mcp__claude-flow__agentdb_controllers mcp__claude-flow__agentdb_health mcp__claude-flow__agentdb_batch mcp__claude-flow__agentdb_feedback mcp__claude-flow__agentdb_consolidate mcp__claude-flow__agentdb_session-start mcp__claude-flow__agentdb_session-end Bash
|
||||
---
|
||||
|
||||
# AgentDB Query
|
||||
|
||||
Query and manage AgentDB's 19 memory controllers.
|
||||
|
||||
## When to use
|
||||
|
||||
When you need to store, retrieve, or search knowledge across agent sessions. AgentDB provides hierarchical storage, causal knowledge graphs, semantic routing, and context synthesis.
|
||||
|
||||
## Steps
|
||||
|
||||
1. **Check health** — call `mcp__claude-flow__agentdb_health` to verify AgentDB is running
|
||||
2. **Start session** — call `mcp__claude-flow__agentdb_session-start` if not already active
|
||||
3. **Store knowledge** — call `mcp__claude-flow__agentdb_hierarchical-store` for structured data
|
||||
4. **Recall knowledge** — call `mcp__claude-flow__agentdb_hierarchical-recall` with a query
|
||||
5. **Search patterns** — call `mcp__claude-flow__agentdb_pattern-search` for learned patterns
|
||||
6. **Synthesize context** — call `mcp__claude-flow__agentdb_context-synthesize` to combine multiple memories
|
||||
7. **Build causal graph** — call `mcp__claude-flow__agentdb_causal-edge` to link related knowledge
|
||||
|
||||
## 19 Controllers
|
||||
|
||||
Call `mcp__claude-flow__agentdb_controllers` to list all available controllers:
|
||||
- Hierarchical store/recall
|
||||
- Pattern store/search
|
||||
- Semantic routing
|
||||
- Context synthesis
|
||||
- Causal edges
|
||||
- Feedback loops
|
||||
- Batch operations
|
||||
- Consolidation
|
||||
|
||||
## CLI alternative
|
||||
|
||||
```bash
|
||||
npx @claude-flow/cli@latest memory search --query "your query" --namespace patterns
|
||||
npx @claude-flow/cli@latest memory store --key "key" --value "value" --namespace patterns
|
||||
npx @claude-flow/cli@latest memory list --namespace patterns
|
||||
```
|
||||
@@ -0,0 +1,49 @@
|
||||
---
|
||||
name: vector-search
|
||||
description: HNSW vector search with RuVector embeddings for 150x-12500x faster semantic retrieval
|
||||
allowed-tools: mcp__claude-flow__embeddings_generate mcp__claude-flow__embeddings_search mcp__claude-flow__embeddings_compare mcp__claude-flow__embeddings_init mcp__claude-flow__embeddings_status mcp__claude-flow__embeddings_hyperbolic mcp__claude-flow__embeddings_neural mcp__claude-flow__ruvllm_hnsw_create mcp__claude-flow__ruvllm_hnsw_add mcp__claude-flow__ruvllm_hnsw_route mcp__claude-flow__memory_search_unified Bash
|
||||
---
|
||||
|
||||
# Vector Search
|
||||
|
||||
HNSW-indexed vector search with RuVector embeddings (384-dim ONNX).
|
||||
|
||||
## When to use
|
||||
|
||||
When you need fast semantic search across large knowledge bases. HNSW provides 150x-12,500x faster search compared to brute-force scanning.
|
||||
|
||||
## Steps
|
||||
|
||||
1. **Check status** — call `mcp__claude-flow__embeddings_status` to verify the embedding engine
|
||||
2. **Initialize** — call `mcp__claude-flow__embeddings_init` if not already active
|
||||
3. **Generate embeddings** — call `mcp__claude-flow__embeddings_generate` for text input
|
||||
4. **Search** — call `mcp__claude-flow__embeddings_search` with a query for semantic matches
|
||||
5. **Compare** — call `mcp__claude-flow__embeddings_compare` to measure similarity between texts
|
||||
6. **Unified search** — call `mcp__claude-flow__memory_search_unified` to search across all namespaces
|
||||
|
||||
## HNSW Index
|
||||
|
||||
For building custom HNSW indexes:
|
||||
- `mcp__claude-flow__ruvllm_hnsw_create` — create a new index
|
||||
- `mcp__claude-flow__ruvllm_hnsw_add` — add vectors to the index
|
||||
- `mcp__claude-flow__ruvllm_hnsw_route` — route queries through the index
|
||||
|
||||
## Hyperbolic embeddings
|
||||
|
||||
For hierarchical data (code trees, org charts), use `mcp__claude-flow__embeddings_hyperbolic` which maps to Poincare ball space.
|
||||
|
||||
## CLI alternative
|
||||
|
||||
```bash
|
||||
npx @claude-flow/cli@latest embeddings search --query "authentication patterns"
|
||||
npx @claude-flow/cli@latest embeddings init
|
||||
npx @claude-flow/cli@latest memory search --query "your query"
|
||||
```
|
||||
|
||||
## Performance
|
||||
|
||||
| Method | Speed |
|
||||
|--------|-------|
|
||||
| Brute-force scan | Baseline |
|
||||
| HNSW (n=500) | 150x faster |
|
||||
| HNSW (n=10,000) | 12,500x faster |
|
||||
@@ -0,0 +1,19 @@
|
||||
{
|
||||
"name": "ruflo-aidefence",
|
||||
"description": "AI safety scanning, PII detection, prompt injection defense, and adaptive threat learning",
|
||||
"version": "0.1.0",
|
||||
"author": {
|
||||
"name": "ruvnet",
|
||||
"url": "https://github.com/ruvnet"
|
||||
},
|
||||
"homepage": "https://github.com/ruvnet/ruflo",
|
||||
"license": "MIT",
|
||||
"keywords": [
|
||||
"ruflo",
|
||||
"aidefence",
|
||||
"safety",
|
||||
"pii",
|
||||
"injection",
|
||||
"security"
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
# ruflo-aidefence
|
||||
|
||||
AI safety scanning, PII detection, prompt injection defense, and adaptive threat learning.
|
||||
|
||||
## Install
|
||||
|
||||
```
|
||||
/plugin marketplace add ruvnet/ruflo
|
||||
/plugin install ruflo-aidefence@ruflo
|
||||
```
|
||||
|
||||
## Features
|
||||
|
||||
- **Safety scanning**: Detect prompt injection, jailbreak attempts, and adversarial content
|
||||
- **PII detection**: Flag emails, SSNs, API keys, and other sensitive data
|
||||
- **Adaptive learning**: Train defenses on confirmed threats to improve detection
|
||||
- **Threat classification**: Categorize threats with confidence scores
|
||||
|
||||
## Commands
|
||||
|
||||
- `/aidefence` -- Detection stats and threat analysis dashboard
|
||||
|
||||
## Skills
|
||||
|
||||
- `safety-scan` -- Scan inputs for prompt injection and unsafe content
|
||||
- `pii-detect` -- Detect PII in text, code, and configurations
|
||||
@@ -0,0 +1,21 @@
|
||||
---
|
||||
name: safety-specialist
|
||||
description: AI safety specialist for threat detection, PII scanning, and adaptive defense training
|
||||
model: sonnet
|
||||
---
|
||||
|
||||
You are an AI safety specialist for the Ruflo AIDefence system. Your responsibilities:
|
||||
|
||||
1. **Scan inputs** for prompt injection, jailbreak attempts, and adversarial content
|
||||
2. **Detect PII** in text, code, and configurations before they enter logs or commits
|
||||
3. **Analyze threats** with detailed classification and confidence scores
|
||||
4. **Train defenses** by feeding confirmed threats back into the learning system
|
||||
5. **Report stats** on detection rates, false positives, and coverage
|
||||
|
||||
Use these MCP tools:
|
||||
- `mcp__claude-flow__aidefence_scan` / `aidefence_analyze` / `aidefence_is_safe` for scanning
|
||||
- `mcp__claude-flow__aidefence_has_pii` / `mcp__claude-flow__transfer_detect-pii` for PII
|
||||
- `mcp__claude-flow__aidefence_learn` to train on confirmed threats
|
||||
- `mcp__claude-flow__aidefence_stats` for metrics
|
||||
|
||||
Always err on the side of caution — flag uncertain content for human review.
|
||||
@@ -0,0 +1,10 @@
|
||||
---
|
||||
name: aidefence
|
||||
description: AIDefence status, detection stats, and threat analysis dashboard
|
||||
---
|
||||
|
||||
Show the AIDefence dashboard:
|
||||
|
||||
1. Call `mcp__claude-flow__aidefence_stats` to get detection rates, scan counts, and learned patterns
|
||||
2. Present a summary with: total scans, threats detected, false positive rate, PII detections
|
||||
3. Show learned threat categories and their detection confidence
|
||||
@@ -0,0 +1,29 @@
|
||||
---
|
||||
name: pii-detect
|
||||
description: Detect and flag personally identifiable information (PII) in text, code, and configurations
|
||||
allowed-tools: mcp__claude-flow__aidefence_has_pii mcp__claude-flow__aidefence_scan mcp__claude-flow__aidefence_analyze mcp__claude-flow__transfer_detect-pii Bash
|
||||
---
|
||||
|
||||
# PII Detection
|
||||
|
||||
Detect personally identifiable information before it enters logs, commits, or responses.
|
||||
|
||||
## When to use
|
||||
|
||||
Before committing code, storing data, or sending responses that might contain PII (emails, phone numbers, SSNs, API keys, passwords).
|
||||
|
||||
## Steps
|
||||
|
||||
1. **Quick PII check** — call `mcp__claude-flow__aidefence_has_pii` with the text for a boolean result
|
||||
2. **Detailed scan** — call `mcp__claude-flow__transfer_detect-pii` for categorized PII findings
|
||||
3. **Full analysis** — call `mcp__claude-flow__aidefence_analyze` for context-aware PII detection
|
||||
4. If PII found, flag the specific locations and suggest redaction
|
||||
|
||||
## PII categories detected
|
||||
|
||||
- Email addresses, phone numbers
|
||||
- Social security numbers, tax IDs
|
||||
- Credit card numbers
|
||||
- API keys, tokens, passwords
|
||||
- Physical addresses
|
||||
- Names linked to sensitive data
|
||||
@@ -0,0 +1,29 @@
|
||||
---
|
||||
name: safety-scan
|
||||
description: Scan inputs for prompt injection, unsafe content, and adversarial attacks using AIDefence
|
||||
allowed-tools: mcp__claude-flow__aidefence_scan mcp__claude-flow__aidefence_analyze mcp__claude-flow__aidefence_is_safe mcp__claude-flow__aidefence_learn mcp__claude-flow__aidefence_stats Bash
|
||||
---
|
||||
|
||||
# Safety Scan
|
||||
|
||||
Scan content for prompt injection, jailbreak attempts, and unsafe patterns.
|
||||
|
||||
## When to use
|
||||
|
||||
Before processing untrusted input (user submissions, API payloads, webhook data), scan it to detect prompt injection, adversarial content, or policy violations.
|
||||
|
||||
## Steps
|
||||
|
||||
1. **Quick safety check** — call `mcp__claude-flow__aidefence_is_safe` with the input text for a boolean safe/unsafe result
|
||||
2. **Deep analysis** — call `mcp__claude-flow__aidefence_analyze` for detailed threat classification and confidence scores
|
||||
3. **Full scan** — call `mcp__claude-flow__aidefence_scan` for comprehensive multi-layer scanning
|
||||
4. **Train defenses** — call `mcp__claude-flow__aidefence_learn` with confirmed threats to improve detection
|
||||
5. **View stats** — call `mcp__claude-flow__aidefence_stats` for detection rates and false positive metrics
|
||||
|
||||
## Threat categories
|
||||
|
||||
- Prompt injection (direct and indirect)
|
||||
- Jailbreak attempts
|
||||
- Data exfiltration patterns
|
||||
- Instruction override attacks
|
||||
- Social engineering prompts
|
||||
@@ -0,0 +1,18 @@
|
||||
{
|
||||
"name": "ruflo-autopilot",
|
||||
"description": "Autonomous /loop-driven task completion with learning, prediction, and progress tracking",
|
||||
"version": "0.1.0",
|
||||
"author": {
|
||||
"name": "ruvnet",
|
||||
"url": "https://github.com/ruvnet"
|
||||
},
|
||||
"homepage": "https://github.com/ruvnet/ruflo",
|
||||
"license": "MIT",
|
||||
"keywords": [
|
||||
"ruflo",
|
||||
"autopilot",
|
||||
"loop",
|
||||
"autonomous",
|
||||
"learning"
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
# ruflo-autopilot
|
||||
|
||||
Autonomous /loop-driven task completion with learning and prediction.
|
||||
|
||||
Combines Ruflo's 10 autopilot MCP tools with Claude Code's native `/loop` + `ScheduleWakeup` for persistent, cache-aware task completion loops.
|
||||
|
||||
## Install
|
||||
|
||||
```
|
||||
/plugin marketplace add ruvnet/ruflo
|
||||
/plugin install ruflo-autopilot@ruflo
|
||||
```
|
||||
|
||||
## Features
|
||||
|
||||
- **Autonomous loops**: Enable autopilot, then `/loop` drives iterative task completion
|
||||
- **Progress tracking**: Monitors team-tasks, swarm-tasks, and file checklists
|
||||
- **Learning**: Discovers success patterns from completed tasks via AgentDB
|
||||
- **Prediction**: Predicts optimal next action based on state and learned patterns
|
||||
- **Cache-aware**: ScheduleWakeup at 270s keeps prompt cache warm between iterations
|
||||
|
||||
## Commands
|
||||
|
||||
- `/autopilot` -- Enable, configure, or disable autopilot
|
||||
- `/autopilot-status` -- Quick progress summary
|
||||
|
||||
## Skills
|
||||
|
||||
- `autopilot-loop` -- How to run an autopilot /loop iteration
|
||||
- `autopilot-predict` -- Use learned patterns to pick the next task
|
||||
@@ -0,0 +1,33 @@
|
||||
---
|
||||
name: autopilot-coordinator
|
||||
description: Autonomous task completion coordinator using /loop and autopilot MCP tools
|
||||
model: sonnet
|
||||
---
|
||||
You are an autopilot coordinator agent. You drive autonomous task completion loops.
|
||||
|
||||
### Workflow
|
||||
|
||||
1. Enable autopilot: call `autopilot_enable` via MCP
|
||||
2. Configure limits: `autopilot_config({ maxIterations: 50, timeoutMinutes: 30 })`
|
||||
3. Check progress: `autopilot_progress` for task breakdown by source
|
||||
4. Predict next action: `autopilot_predict` for intelligent task selection
|
||||
5. Execute the task (delegate to specialist agents as needed)
|
||||
6. After each task, schedule next iteration via `ScheduleWakeup` at 270s
|
||||
7. When all tasks complete or limits reached, call `autopilot_disable`
|
||||
|
||||
### Decision Logic
|
||||
|
||||
- All tasks complete -> disable autopilot, report summary
|
||||
- Max iterations reached -> disable, warn about remaining tasks
|
||||
- Timeout reached -> disable, list incomplete tasks
|
||||
- High-confidence prediction -> execute immediately
|
||||
- Low-confidence prediction -> check task list, pick highest priority
|
||||
|
||||
### Memory Integration
|
||||
|
||||
After successful task completion, store patterns:
|
||||
```bash
|
||||
npx @claude-flow/cli@latest memory store --namespace patterns --key "autopilot-PATTERN" --value "WHAT_WORKED"
|
||||
```
|
||||
|
||||
Call `autopilot_learn` periodically to discover cross-task success patterns.
|
||||
@@ -0,0 +1,15 @@
|
||||
---
|
||||
name: autopilot-status
|
||||
description: Quick autopilot progress summary with task completion stats
|
||||
---
|
||||
$ARGUMENTS
|
||||
Show autopilot progress. Calls `autopilot_status` and `autopilot_progress` via MCP.
|
||||
|
||||
Displays:
|
||||
- Enabled/disabled state
|
||||
- Iteration count vs max
|
||||
- Elapsed time vs timeout
|
||||
- Task completion by source (team-tasks, swarm-tasks, file-checklist)
|
||||
- Overall completion percentage
|
||||
|
||||
For detailed task breakdown, use `autopilot_progress`. For event log, use `autopilot_log`.
|
||||
@@ -0,0 +1,18 @@
|
||||
---
|
||||
name: autopilot
|
||||
description: Enable, configure, or disable autonomous task completion
|
||||
---
|
||||
$ARGUMENTS
|
||||
Manage Ruflo autopilot for autonomous /loop-driven task completion.
|
||||
|
||||
Usage:
|
||||
- `/autopilot enable` -- Enable autopilot and start the completion loop
|
||||
- `/autopilot disable` -- Disable autopilot, let agents stop
|
||||
- `/autopilot config --max-iterations 50 --timeout 30` -- Set limits
|
||||
- `/autopilot reset` -- Reset iteration counter and restart timer
|
||||
- `/autopilot learn` -- Discover success patterns from completed tasks
|
||||
- `/autopilot history KEYWORD` -- Search past completion episodes
|
||||
|
||||
Parse $ARGUMENTS to determine the subcommand. If no arguments, show status via `autopilot_status`.
|
||||
|
||||
After enabling, start a `/loop` with the `autopilot-loop` skill to begin autonomous iteration. Use `ScheduleWakeup` at 270s delay for cache-warm scheduling.
|
||||
@@ -0,0 +1,26 @@
|
||||
---
|
||||
name: autopilot-loop
|
||||
description: Run an autonomous /loop iteration -- check progress, work on next task, schedule next wake
|
||||
allowed-tools: mcp__claude-flow__autopilot_status mcp__claude-flow__autopilot_predict mcp__claude-flow__autopilot_log mcp__claude-flow__autopilot_progress mcp__claude-flow__autopilot_disable ScheduleWakeup Agent
|
||||
---
|
||||
Run one autopilot iteration using Claude Code's native /loop:
|
||||
|
||||
1. Check status: `mcp__claude-flow__autopilot_status`
|
||||
2. If all tasks complete or max iterations reached, call `mcp__claude-flow__autopilot_disable` and stop
|
||||
3. Get prediction: `mcp__claude-flow__autopilot_predict` for the optimal next action
|
||||
4. Execute the predicted task (spawn agent, edit code, run tests, etc.)
|
||||
5. Log via `mcp__claude-flow__autopilot_log`
|
||||
6. Schedule next: `ScheduleWakeup({ delaySeconds: 270, reason: "next autopilot iteration" })`
|
||||
|
||||
### Cache-Aware Scheduling
|
||||
|
||||
Always use delay 270s (under 300s cache TTL) to keep the prompt cache warm between iterations.
|
||||
|
||||
### Task Sources
|
||||
|
||||
Autopilot discovers tasks from:
|
||||
- **team-tasks**: Claude Code TaskList entries
|
||||
- **swarm-tasks**: MCP task_list entries
|
||||
- **file-checklist**: Markdown checkbox items in tracked files
|
||||
|
||||
Configure: `mcp__claude-flow__autopilot_config({ taskSources: ["team-tasks", "swarm-tasks"] })`
|
||||
@@ -0,0 +1,25 @@
|
||||
---
|
||||
name: autopilot-predict
|
||||
description: Use learned patterns and current state to predict the optimal next action
|
||||
allowed-tools: mcp__claude-flow__autopilot_predict mcp__claude-flow__autopilot_progress mcp__claude-flow__autopilot_learn mcp__claude-flow__autopilot_history
|
||||
---
|
||||
Predict what to work on next using Ruflo autopilot intelligence:
|
||||
|
||||
1. Call `mcp__claude-flow__autopilot_predict` for the recommended next action
|
||||
2. If confidence > 0.7, execute the prediction directly
|
||||
3. If confidence < 0.7, check `mcp__claude-flow__autopilot_progress` for task breakdown
|
||||
4. Pick the highest-priority incomplete task
|
||||
5. After completing work, call `mcp__claude-flow__autopilot_learn` to update patterns
|
||||
|
||||
### Learning Pipeline
|
||||
|
||||
- `mcp__claude-flow__autopilot_learn` -- discover success patterns from completed tasks
|
||||
- `mcp__claude-flow__autopilot_history({ query: "KEYWORD" })` -- search past completions
|
||||
- Patterns are stored in AgentDB for cross-session recall
|
||||
|
||||
### Integration with /loop
|
||||
|
||||
When running inside a `/loop`, the predict skill guides each iteration:
|
||||
- High confidence prediction -> execute immediately
|
||||
- Low confidence -> fall back to task list priority order
|
||||
- No tasks remaining -> disable autopilot and exit loop
|
||||
@@ -0,0 +1,19 @@
|
||||
{
|
||||
"name": "ruflo-browser",
|
||||
"description": "Agentic browser automation with Playwright for testing, scraping, and UI interaction",
|
||||
"version": "0.1.0",
|
||||
"author": {
|
||||
"name": "ruvnet",
|
||||
"url": "https://github.com/ruvnet"
|
||||
},
|
||||
"homepage": "https://github.com/ruvnet/ruflo",
|
||||
"license": "MIT",
|
||||
"keywords": [
|
||||
"ruflo",
|
||||
"browser",
|
||||
"playwright",
|
||||
"testing",
|
||||
"automation",
|
||||
"scraping"
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
# ruflo-browser
|
||||
|
||||
Agentic browser automation with Playwright for testing, scraping, and UI interaction.
|
||||
|
||||
## Install
|
||||
|
||||
```
|
||||
/plugin marketplace add ruvnet/ruflo
|
||||
/plugin install ruflo-browser@ruflo
|
||||
```
|
||||
|
||||
## Features
|
||||
|
||||
- **Browser testing**: Navigate, click, fill forms, and validate UI with 23 browser tools
|
||||
- **Screenshots**: Capture visual state for regression testing
|
||||
- **Web scraping**: Extract structured data with DOM queries and accessibility trees
|
||||
- **Session management**: Multiple concurrent browser sessions
|
||||
|
||||
## Commands
|
||||
|
||||
- `/browser` -- List active sessions, take screenshots, manage tabs
|
||||
|
||||
## Skills
|
||||
|
||||
- `browser-test` -- Automated UI testing with Playwright
|
||||
- `browser-scrape` -- Extract structured data from web pages
|
||||
@@ -0,0 +1,22 @@
|
||||
---
|
||||
name: browser-agent
|
||||
description: Browser automation agent for UI testing, web scraping, and interactive page validation
|
||||
model: sonnet
|
||||
---
|
||||
|
||||
You are a browser automation agent using Playwright via Ruflo's browser MCP tools. Your responsibilities:
|
||||
|
||||
1. **Navigate** to URLs and interact with page elements
|
||||
2. **Test UI flows** by clicking, filling forms, and validating outcomes
|
||||
3. **Extract data** from web pages using DOM queries and accessibility trees
|
||||
4. **Screenshot** pages for visual validation and regression testing
|
||||
5. **Manage sessions** across multiple browser tabs
|
||||
|
||||
Use these MCP tools:
|
||||
- `mcp__claude-flow__browser_open` / `browser_close` for session management
|
||||
- `mcp__claude-flow__browser_click` / `browser_fill` / `browser_type` for interaction
|
||||
- `mcp__claude-flow__browser_screenshot` / `browser_snapshot` for capture
|
||||
- `mcp__claude-flow__browser_get-text` / `browser_eval` for extraction
|
||||
- `mcp__claude-flow__browser_wait` for synchronization
|
||||
|
||||
Always wait for elements before interacting and take screenshots to document results.
|
||||
@@ -0,0 +1,10 @@
|
||||
---
|
||||
name: browser
|
||||
description: Browser session management -- list active sessions, take screenshots, close sessions
|
||||
---
|
||||
|
||||
Manage browser sessions:
|
||||
|
||||
1. Call `mcp__claude-flow__browser_session-list` to show all active browser sessions
|
||||
2. Show session IDs, current URLs, and page titles
|
||||
3. Offer to screenshot or close specific sessions
|
||||
@@ -0,0 +1,30 @@
|
||||
---
|
||||
name: browser-scrape
|
||||
description: Extract structured data from web pages using browser automation and DOM queries
|
||||
allowed-tools: mcp__claude-flow__browser_open mcp__claude-flow__browser_get-text mcp__claude-flow__browser_get-value mcp__claude-flow__browser_eval mcp__claude-flow__browser_snapshot mcp__claude-flow__browser_screenshot mcp__claude-flow__browser_scroll mcp__claude-flow__browser_wait mcp__claude-flow__browser_click mcp__claude-flow__browser_close mcp__claude-flow__browser_session-list Bash
|
||||
---
|
||||
|
||||
# Browser Scraping
|
||||
|
||||
Extract structured data from web pages using browser automation.
|
||||
|
||||
## When to use
|
||||
|
||||
When you need to gather information from web pages that require JavaScript rendering, authentication, or dynamic content loading.
|
||||
|
||||
## Steps
|
||||
|
||||
1. **Open page** — call `mcp__claude-flow__browser_open` with the target URL
|
||||
2. **Wait for content** — call `mcp__claude-flow__browser_wait` for dynamic content to load
|
||||
3. **Get accessibility tree** — call `mcp__claude-flow__browser_snapshot` for structured page content
|
||||
4. **Extract text** — call `mcp__claude-flow__browser_get-text` with CSS selectors
|
||||
5. **Run queries** — call `mcp__claude-flow__browser_eval` with JavaScript to extract structured data
|
||||
6. **Paginate** — use `browser_click` on next/load-more buttons, then repeat extraction
|
||||
7. **Close** — call `mcp__claude-flow__browser_close` when done
|
||||
|
||||
## Best practices
|
||||
|
||||
- Prefer `browser_snapshot` (accessibility tree) over raw HTML for structured extraction
|
||||
- Use `browser_eval` with `document.querySelectorAll` for bulk extraction
|
||||
- Add `browser_wait` between page loads to avoid timing issues
|
||||
- Respect robots.txt and rate limits
|
||||
@@ -0,0 +1,35 @@
|
||||
---
|
||||
name: browser-test
|
||||
description: Automated browser testing with Playwright -- navigate, interact, screenshot, and validate UI
|
||||
allowed-tools: mcp__claude-flow__browser_open mcp__claude-flow__browser_click mcp__claude-flow__browser_fill mcp__claude-flow__browser_type mcp__claude-flow__browser_press mcp__claude-flow__browser_check mcp__claude-flow__browser_uncheck mcp__claude-flow__browser_select mcp__claude-flow__browser_hover mcp__claude-flow__browser_wait mcp__claude-flow__browser_screenshot mcp__claude-flow__browser_snapshot mcp__claude-flow__browser_get-text mcp__claude-flow__browser_get-title mcp__claude-flow__browser_get-url mcp__claude-flow__browser_get-value mcp__claude-flow__browser_eval mcp__claude-flow__browser_close mcp__claude-flow__browser_session-list Bash
|
||||
---
|
||||
|
||||
# Browser Testing
|
||||
|
||||
Automated UI testing using Playwright via the ruflo browser MCP tools.
|
||||
|
||||
## When to use
|
||||
|
||||
When you need to verify UI functionality, test user flows, or validate that frontend changes work correctly in a real browser.
|
||||
|
||||
## Steps
|
||||
|
||||
1. **Open page** — call `mcp__claude-flow__browser_open` with the target URL
|
||||
2. **Interact** — use `browser_click`, `browser_fill`, `browser_type`, `browser_select` for form inputs
|
||||
3. **Wait** — call `mcp__claude-flow__browser_wait` for elements to appear or network idle
|
||||
4. **Validate** — call `browser_get-text` / `browser_get-value` to check content
|
||||
5. **Screenshot** — call `mcp__claude-flow__browser_screenshot` to capture visual state
|
||||
6. **Snapshot** — call `mcp__claude-flow__browser_snapshot` for accessibility tree
|
||||
7. **Clean up** — call `mcp__claude-flow__browser_close` when done
|
||||
|
||||
## Navigation
|
||||
|
||||
- `browser_back` / `browser_forward` for history navigation
|
||||
- `browser_reload` to refresh the page
|
||||
- `browser_scroll` to scroll to elements or coordinates
|
||||
|
||||
## Tips
|
||||
|
||||
- Use `browser_wait` before assertions to handle async rendering
|
||||
- Take screenshots before and after interactions for visual regression
|
||||
- Use `browser_eval` for custom JavaScript assertions
|
||||
@@ -0,0 +1,17 @@
|
||||
{
|
||||
"name": "ruflo-core",
|
||||
"description": "Core Ruflo MCP tools, commands, and Claude Code orchestration patterns",
|
||||
"version": "0.1.0",
|
||||
"author": {
|
||||
"name": "ruvnet",
|
||||
"url": "https://github.com/ruvnet"
|
||||
},
|
||||
"homepage": "https://github.com/ruvnet/ruflo",
|
||||
"license": "MIT",
|
||||
"keywords": [
|
||||
"ruflo",
|
||||
"mcp",
|
||||
"orchestration",
|
||||
"claude-code"
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
# ruflo-core
|
||||
|
||||
Core Ruflo MCP tools, commands, and Claude Code orchestration patterns.
|
||||
|
||||
## Install
|
||||
|
||||
```
|
||||
/plugin marketplace add ruvnet/ruflo
|
||||
/plugin install ruflo-core@ruflo
|
||||
```
|
||||
|
||||
## What's Included
|
||||
|
||||
- **MCP Server**: 314 tools via `@claude-flow/cli` (memory, agents, swarm, hooks, neural, security)
|
||||
- **CLI Commands**: 26 commands with 140+ subcommands for agent orchestration
|
||||
- **3-Tier Model Routing**: Agent Booster (WASM), Haiku, Sonnet/Opus with automatic cost optimization
|
||||
- **Session Management**: Persistent sessions with cross-conversation learning
|
||||
- **Hooks System**: 17 hooks + 12 background workers for self-learning automation
|
||||
|
||||
## Configuration
|
||||
|
||||
The MCP server starts automatically when this plugin is active. Override environment variables in `.mcp.json` as needed.
|
||||
@@ -0,0 +1,13 @@
|
||||
---
|
||||
name: coder
|
||||
description: Implementation specialist for writing clean, efficient code following project patterns
|
||||
model: sonnet
|
||||
---
|
||||
You are a code implementation specialist working within a Ruflo-coordinated swarm. Write clean, typed, tested code. Prefer editing existing files. Follow TDD London School. Use `npx @claude-flow/cli@latest hooks pre-edit --file "$FILE"` before editing and `npx @claude-flow/cli@latest hooks post-edit --file "$FILE" --success true` after.
|
||||
|
||||
Guidelines:
|
||||
- Read files before editing. Never create unnecessary files.
|
||||
- Keep functions under 20 lines. Use typed interfaces for all public APIs.
|
||||
- Apply SOLID principles. Validate inputs at system boundaries.
|
||||
- Store successful patterns: `npx @claude-flow/cli@latest memory store --key "pattern-NAME" --value "DESCRIPTION" --namespace patterns`
|
||||
- Search for prior art: `npx @claude-flow/cli@latest memory search --query "TOPIC" --namespace patterns`
|
||||
@@ -0,0 +1,15 @@
|
||||
---
|
||||
name: researcher
|
||||
description: Research specialist for analyzing requirements, codebase patterns, and prior art
|
||||
model: sonnet
|
||||
---
|
||||
You are a research specialist within a Ruflo-coordinated swarm. Analyze requirements, explore codebases, and surface relevant patterns before implementation begins.
|
||||
|
||||
Workflow:
|
||||
1. Search memory for prior work: `npx @claude-flow/cli@latest memory search --query "TOPIC" --namespace patterns`
|
||||
2. Use Read, Grep, and Glob to explore the codebase for relevant files and conventions.
|
||||
3. Summarize findings: existing patterns, dependencies, edge cases, and risks.
|
||||
4. Store findings: `npx @claude-flow/cli@latest memory store --key "research-TOPIC" --value "FINDINGS" --namespace tasks`
|
||||
5. Report via `npx @claude-flow/cli@latest hooks post-task --task-id "TASK_ID" --success true`
|
||||
|
||||
Never modify source code. Your output informs architects, coders, and testers.
|
||||
@@ -0,0 +1,19 @@
|
||||
---
|
||||
name: reviewer
|
||||
description: Code review specialist for quality, security, and best-practice enforcement
|
||||
model: sonnet
|
||||
---
|
||||
You are a code review specialist within a Ruflo-coordinated swarm. Review code for correctness, security, performance, and adherence to project conventions.
|
||||
|
||||
Checklist:
|
||||
- Correctness: logic errors, off-by-one, null/undefined handling
|
||||
- Security: input validation, injection risks, secrets in code, path traversal
|
||||
- Performance: unnecessary allocations, O(n^2) loops, missing memoization
|
||||
- Style: naming conventions, file length (<500 lines), function length (<20 lines)
|
||||
- Types: proper interfaces, no `any` unless justified
|
||||
- Tests: adequate coverage, edge cases, mocks for externals
|
||||
|
||||
Report findings with severity (critical/warning/info). Store patterns:
|
||||
`npx @claude-flow/cli@latest memory store --key "review-PATTERN" --value "DESCRIPTION" --namespace patterns`
|
||||
|
||||
Use `npx @claude-flow/cli@latest hooks post-task --task-id "TASK_ID" --success true` when complete.
|
||||
@@ -0,0 +1,11 @@
|
||||
---
|
||||
name: status
|
||||
description: Show Ruflo system health, MCP server status, and active agents
|
||||
---
|
||||
$ARGUMENTS
|
||||
Run diagnostics and show system status.
|
||||
```bash
|
||||
npx @claude-flow/cli@latest doctor
|
||||
npx @claude-flow/cli@latest status
|
||||
```
|
||||
To auto-fix issues, run `npx @claude-flow/cli@latest doctor --fix` separately.
|
||||
@@ -0,0 +1,53 @@
|
||||
---
|
||||
name: discover-plugins
|
||||
description: Discover and recommend ruflo plugins based on your workflow, installed MCP tools, and current task
|
||||
allowed-tools: mcp__claude-flow__transfer_plugin-search mcp__claude-flow__transfer_plugin-info mcp__claude-flow__transfer_plugin-featured mcp__claude-flow__transfer_plugin-official mcp__claude-flow__transfer_store-search mcp__claude-flow__transfer_store-featured mcp__claude-flow__transfer_store-trending mcp__claude-flow__transfer_store-info mcp__claude-flow__guidance_discover mcp__claude-flow__guidance_recommend mcp__claude-flow__guidance_capabilities mcp__claude-flow__mcp_status Bash Read
|
||||
---
|
||||
|
||||
# Discover Plugins
|
||||
|
||||
Find and recommend ruflo plugins for your workflow.
|
||||
|
||||
## When to use
|
||||
|
||||
When starting a new project, exploring ruflo capabilities, or wondering which plugins would help with your current task.
|
||||
|
||||
## Steps
|
||||
|
||||
1. **Check installed** — run `ls plugins/` to see what's already installed
|
||||
2. **Browse marketplace** — call `mcp__claude-flow__transfer_plugin-featured` for recommended plugins
|
||||
3. **Search by need** — call `mcp__claude-flow__transfer_plugin-search` with keywords matching your task
|
||||
4. **Get recommendations** — call `mcp__claude-flow__guidance_recommend` with your current task description for personalized suggestions
|
||||
5. **Check capabilities** — call `mcp__claude-flow__guidance_capabilities` to see what each plugin enables
|
||||
6. **Show details** — call `mcp__claude-flow__transfer_plugin-info` for full plugin details
|
||||
|
||||
## Available plugins
|
||||
|
||||
| Plugin | Category | What it adds |
|
||||
|--------|----------|-------------|
|
||||
| **ruflo-core** | Core | MCP server, status, doctor, base agents |
|
||||
| **ruflo-swarm** | Coordination | Swarm topologies, Monitor, worktree isolation |
|
||||
| **ruflo-autopilot** | Automation | Autonomous /loop task completion |
|
||||
| **ruflo-intelligence** | Learning | SONA patterns, trajectory learning, routing |
|
||||
| **ruflo-agentdb** | Memory | AgentDB, HNSW vector search, RuVector |
|
||||
| **ruflo-loop-workers** | Automation | Background workers, CronCreate scheduling |
|
||||
| **ruflo-security-audit** | Security | CVE scanning, dependency checks |
|
||||
| **ruflo-rag-memory** | Memory | Simple store/search/recall interface |
|
||||
| **ruflo-testgen** | Testing | Test gap detection, TDD workflow |
|
||||
| **ruflo-docs** | Docs | Doc generation, drift detection |
|
||||
| **ruflo-aidefence** | Security | AI safety, PII detection, prompt defense |
|
||||
| **ruflo-browser** | Testing | Playwright browser automation |
|
||||
| **ruflo-jujutsu** | Git | Diff analysis, risk scoring, reviewers |
|
||||
| **ruflo-wasm** | Sandbox | WASM agent sandboxing and gallery |
|
||||
| **ruflo-workflows** | Automation | Workflow templates and orchestration |
|
||||
| **ruflo-daa** | Learning | Dynamic Agentic Architecture, cognitive patterns |
|
||||
| **ruflo-ruvllm** | LLM | Local inference, MicroLoRA, chat formatting |
|
||||
| **ruflo-rvf** | Memory | RVF portable memory, session persistence |
|
||||
| **ruflo-plugin-creator** | Dev Tools | Scaffold and validate new plugins |
|
||||
|
||||
## Install any plugin
|
||||
|
||||
```
|
||||
/plugin marketplace add ruvnet/ruflo
|
||||
/plugin install <plugin-name>@ruflo
|
||||
```
|
||||
@@ -0,0 +1,13 @@
|
||||
---
|
||||
name: doctor
|
||||
description: Run health checks on the Ruflo installation and fix common issues
|
||||
allowed-tools: Bash(npx *)
|
||||
---
|
||||
Run `npx @claude-flow/cli@latest doctor --fix` to diagnose and auto-repair common issues.
|
||||
|
||||
Checks: Node.js 20+, npm 9+, git, config validity, daemon status, memory database, API keys, MCP servers, disk space, TypeScript.
|
||||
|
||||
Targeted fixes:
|
||||
- Memory: `npx @claude-flow/cli@latest memory init --force`
|
||||
- Daemon: `npx @claude-flow/cli@latest daemon start`
|
||||
- Config: `npx @claude-flow/cli@latest config reset`
|
||||
@@ -0,0 +1,8 @@
|
||||
---
|
||||
name: init-project
|
||||
description: Initialize a new Ruflo project with MCP tools, hooks, and agent configuration
|
||||
allowed-tools: Bash(npx *) Read Write Edit
|
||||
---
|
||||
Run `npx @claude-flow/cli@latest init --wizard` to set up the project interactively, or `npx @claude-flow/cli@latest init --preset standard` for defaults.
|
||||
|
||||
This creates CLAUDE.md, .claude/settings.json, and .claude-flow/ config with MCP server registration for the `ruflo` MCP tools.
|
||||
@@ -0,0 +1,18 @@
|
||||
{
|
||||
"name": "ruflo-daa",
|
||||
"description": "Dynamic Agentic Architecture with cognitive patterns, knowledge sharing, and adaptive agents",
|
||||
"version": "0.1.0",
|
||||
"author": {
|
||||
"name": "ruvnet",
|
||||
"url": "https://github.com/ruvnet"
|
||||
},
|
||||
"homepage": "https://github.com/ruvnet/ruflo",
|
||||
"license": "MIT",
|
||||
"keywords": [
|
||||
"ruflo",
|
||||
"daa",
|
||||
"cognitive",
|
||||
"adaptive",
|
||||
"knowledge-sharing"
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
# ruflo-daa
|
||||
|
||||
Dynamic Agentic Architecture with cognitive patterns, knowledge sharing, and adaptive agents.
|
||||
|
||||
## Install
|
||||
|
||||
```
|
||||
/plugin marketplace add ruvnet/ruflo
|
||||
/plugin install ruflo-daa@ruflo
|
||||
```
|
||||
|
||||
## Features
|
||||
|
||||
- **Adaptive agents**: Agents that learn and evolve from interactions
|
||||
- **Cognitive patterns**: Structured reasoning strategies for decision-making
|
||||
- **Knowledge sharing**: Cross-agent learning and collective improvement
|
||||
- **Performance tracking**: Efficiency and accuracy metrics over time
|
||||
|
||||
## Commands
|
||||
|
||||
- `/daa` -- DAA dashboard with learning metrics and active agents
|
||||
|
||||
## Skills
|
||||
|
||||
- `daa-agent` -- Create and adapt Dynamic Agentic Architecture agents
|
||||
- `cognitive-pattern` -- Define cognitive patterns for agent reasoning
|
||||
@@ -0,0 +1,22 @@
|
||||
---
|
||||
name: daa-specialist
|
||||
description: Dynamic Agentic Architecture specialist for adaptive agents, cognitive patterns, and knowledge sharing
|
||||
model: sonnet
|
||||
---
|
||||
|
||||
You are a DAA specialist for Ruflo's Dynamic Agentic Architecture. Your responsibilities:
|
||||
|
||||
1. **Create adaptive agents** that learn and evolve from interactions
|
||||
2. **Define cognitive patterns** for structured reasoning and decision-making
|
||||
3. **Monitor learning** and adaptation progress across agents
|
||||
4. **Share knowledge** between agents for collective improvement
|
||||
5. **Design workflows** that leverage cognitive patterns for intelligent execution
|
||||
|
||||
Use these MCP tools:
|
||||
- `mcp__claude-flow__daa_agent_create` / `daa_agent_adapt` for agent management
|
||||
- `mcp__claude-flow__daa_cognitive_pattern` for reasoning patterns
|
||||
- `mcp__claude-flow__daa_workflow_create` / `daa_workflow_execute` for workflows
|
||||
- `mcp__claude-flow__daa_knowledge_share` for cross-agent learning
|
||||
- `mcp__claude-flow__daa_learning_status` / `daa_performance_metrics` for monitoring
|
||||
|
||||
Focus on creating agents that improve measurably over time through feedback loops.
|
||||
@@ -0,0 +1,10 @@
|
||||
---
|
||||
name: daa
|
||||
description: Dynamic Agentic Architecture status -- learning metrics, active agents, cognitive patterns
|
||||
---
|
||||
|
||||
Show DAA dashboard:
|
||||
|
||||
1. Call `mcp__claude-flow__daa_learning_status` to get learning metrics across all DAA agents
|
||||
2. Call `mcp__claude-flow__daa_performance_metrics` for efficiency and accuracy stats
|
||||
3. Present: active agents, adaptation progress, knowledge sharing events, cognitive patterns in use
|
||||
@@ -0,0 +1,28 @@
|
||||
---
|
||||
name: cognitive-pattern
|
||||
description: Define and manage cognitive patterns for agent reasoning and decision-making
|
||||
allowed-tools: mcp__claude-flow__daa_cognitive_pattern mcp__claude-flow__daa_workflow_create mcp__claude-flow__daa_workflow_execute mcp__claude-flow__daa_knowledge_share mcp__claude-flow__daa_learning_status Bash
|
||||
---
|
||||
|
||||
# Cognitive Pattern
|
||||
|
||||
Define cognitive patterns that guide agent reasoning and decision-making.
|
||||
|
||||
## When to use
|
||||
|
||||
When you want to codify reasoning strategies, decision trees, or problem-solving approaches that agents can use and improve over time.
|
||||
|
||||
## Steps
|
||||
|
||||
1. **Define pattern** — call `mcp__claude-flow__daa_cognitive_pattern` with the pattern structure and triggers
|
||||
2. **Create workflow** — call `mcp__claude-flow__daa_workflow_create` to embed the pattern in an executable workflow
|
||||
3. **Execute** — call `mcp__claude-flow__daa_workflow_execute` to run the cognitive workflow
|
||||
4. **Evaluate** — call `mcp__claude-flow__daa_learning_status` to see how the pattern performs
|
||||
5. **Share** — call `mcp__claude-flow__daa_knowledge_share` to propagate successful patterns
|
||||
|
||||
## Pattern types
|
||||
|
||||
- **Decision trees** — structured if/then reasoning
|
||||
- **Chain of thought** — step-by-step problem decomposition
|
||||
- **Analogy mapping** — solve new problems by referencing similar solved ones
|
||||
- **Consensus patterns** — multi-perspective evaluation before deciding
|
||||
@@ -0,0 +1,30 @@
|
||||
---
|
||||
name: daa-agent
|
||||
description: Create and adapt Dynamic Agentic Architecture agents that learn and evolve
|
||||
allowed-tools: mcp__claude-flow__daa_agent_create mcp__claude-flow__daa_agent_adapt mcp__claude-flow__daa_learning_status mcp__claude-flow__daa_performance_metrics mcp__claude-flow__daa_knowledge_share Bash
|
||||
---
|
||||
|
||||
# DAA Agent
|
||||
|
||||
Create agents with Dynamic Agentic Architecture that adapt and learn over time.
|
||||
|
||||
## When to use
|
||||
|
||||
When you need agents that go beyond static configurations — agents that adapt their behavior based on performance metrics, learn from interactions, and share knowledge with other agents.
|
||||
|
||||
## Steps
|
||||
|
||||
1. **Create agent** — call `mcp__claude-flow__daa_agent_create` with initial configuration and learning parameters
|
||||
2. **Monitor learning** — call `mcp__claude-flow__daa_learning_status` to see adaptation progress
|
||||
3. **Check performance** — call `mcp__claude-flow__daa_performance_metrics` for efficiency and accuracy metrics
|
||||
4. **Adapt** — call `mcp__claude-flow__daa_agent_adapt` to trigger manual adaptation based on feedback
|
||||
5. **Share knowledge** — call `mcp__claude-flow__daa_knowledge_share` to propagate learnings to other agents
|
||||
|
||||
## DAA vs static agents
|
||||
|
||||
| Aspect | Static Agent | DAA Agent |
|
||||
|--------|-------------|-----------|
|
||||
| Behavior | Fixed configuration | Adapts over time |
|
||||
| Learning | None | Continuous from interactions |
|
||||
| Knowledge | Isolated | Shared across agents |
|
||||
| Performance | Constant | Improves with use |
|
||||
@@ -0,0 +1,17 @@
|
||||
{
|
||||
"name": "ruflo-docs",
|
||||
"description": "Documentation generation, API docs, and drift detection",
|
||||
"version": "0.1.0",
|
||||
"author": {
|
||||
"name": "ruvnet",
|
||||
"url": "https://github.com/ruvnet"
|
||||
},
|
||||
"homepage": "https://github.com/ruvnet/ruflo",
|
||||
"license": "MIT",
|
||||
"keywords": [
|
||||
"ruflo",
|
||||
"documentation",
|
||||
"api-docs",
|
||||
"drift-detection"
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
# ruflo-docs
|
||||
|
||||
Documentation generation, drift detection, and API docs automation.
|
||||
|
||||
## Install
|
||||
|
||||
```
|
||||
/plugin marketplace add ruvnet/ruflo
|
||||
/plugin install ruflo-docs@ruflo
|
||||
```
|
||||
|
||||
## What's Included
|
||||
|
||||
- **Auto-Documentation**: Background worker generates docs from code changes
|
||||
- **Drift Detection**: Identifies when docs fall out of sync with implementation
|
||||
- **API Docs**: Automated API documentation from TypeScript interfaces and JSDoc
|
||||
- **CAPABILITIES.md Generation**: Full capabilities reference via `init` command
|
||||
- **Document Worker**: Background `document` worker triggers on API changes
|
||||
- **SPARC Integration**: Uses documenter and docs-writer agent patterns
|
||||
|
||||
## Requires
|
||||
|
||||
- `ruflo-core` plugin (provides MCP server)
|
||||
@@ -0,0 +1,18 @@
|
||||
---
|
||||
name: docs-writer
|
||||
description: Documentation specialist -- generates and maintains project documentation
|
||||
model: sonnet
|
||||
---
|
||||
You are a documentation specialist. Your responsibilities:
|
||||
|
||||
1. Generate API docs from JSDoc/TSDoc annotations
|
||||
2. Maintain README and architecture docs for accuracy
|
||||
3. Detect documentation drift (code changed, docs didn't)
|
||||
4. Write clear, concise documentation following project conventions
|
||||
|
||||
### Workflow
|
||||
|
||||
1. Identify what needs documenting (new APIs, changed behavior, missing docs)
|
||||
2. Read source code to understand the public API surface
|
||||
3. Generate documentation with examples and usage patterns
|
||||
4. Store successful doc patterns: `npx @claude-flow/cli@latest memory store --key "doc-pattern-NAME" --value "APPROACH" --namespace patterns`
|
||||
@@ -0,0 +1,21 @@
|
||||
---
|
||||
name: docs
|
||||
description: Generate or update documentation for a file, module, or the entire project
|
||||
---
|
||||
$ARGUMENTS
|
||||
|
||||
Generate or update documentation using the document worker and drift detection.
|
||||
|
||||
**Full project**: `npx @claude-flow/cli@latest hooks worker dispatch --trigger document`
|
||||
**Specific scope**: `npx @claude-flow/cli@latest hooks worker dispatch --trigger document --scope api`
|
||||
|
||||
Parse $ARGUMENTS to determine scope:
|
||||
- If a file path is given, generate docs for that file
|
||||
- If "api" is given, generate API documentation
|
||||
- If no arguments, run full project documentation generation
|
||||
|
||||
Steps:
|
||||
1. Analyze the target for public APIs and existing documentation
|
||||
2. Detect drift between code and docs
|
||||
3. Generate or update documentation
|
||||
4. Report what was created or changed
|
||||
@@ -0,0 +1,20 @@
|
||||
---
|
||||
name: api-docs
|
||||
description: Generate API documentation from source code with JSDoc and OpenAPI support
|
||||
allowed-tools: Bash(npx *) mcp__claude-flow__hooks_worker-dispatch Read Write Grep
|
||||
---
|
||||
Generate API documentation from TypeScript/JavaScript source:
|
||||
|
||||
1. **Scan exports**: Find all public functions, classes, and interfaces
|
||||
2. **Extract JSDoc**: Parse `@param`, `@returns`, `@throws`, `@example` annotations
|
||||
3. **Generate missing docs**: Add JSDoc for undocumented public APIs
|
||||
4. **OpenAPI spec**: For HTTP endpoints, generate OpenAPI 3.0 definitions
|
||||
|
||||
Dispatch via MCP: `mcp__claude-flow__hooks_worker-dispatch({ trigger: "document", scope: "api" })`
|
||||
|
||||
Conventions:
|
||||
- Every public export must have a JSDoc comment
|
||||
- Include `@param` with type and description
|
||||
- Include `@returns` with type and description
|
||||
- Include `@throws` for known error conditions
|
||||
- Include `@example` for non-obvious usage
|
||||
@@ -0,0 +1,18 @@
|
||||
---
|
||||
name: doc-gen
|
||||
description: Generate and maintain documentation with drift detection
|
||||
allowed-tools: Bash(npx *) mcp__claude-flow__hooks_worker-dispatch mcp__claude-flow__memory_store CronCreate Read Write
|
||||
---
|
||||
Generate docs via MCP worker dispatch:
|
||||
`mcp__claude-flow__hooks_worker-dispatch({ trigger: "document" })`
|
||||
|
||||
For continuous doc maintenance via CronCreate:
|
||||
`CronCreate({ schedule: "0 */2 * * *", prompt: "Run document worker" })`
|
||||
|
||||
Detect drift by comparing current code against existing docs and flagging inconsistencies.
|
||||
|
||||
Scoped generation:
|
||||
- API docs: `npx @claude-flow/cli@latest hooks worker dispatch --trigger document --scope api`
|
||||
- Full project: `npx @claude-flow/cli@latest hooks worker dispatch --trigger document --scope full`
|
||||
|
||||
Store the approach: `mcp__claude-flow__memory_store({ key: "doc-pattern", value: "APPROACH", namespace: "patterns" })`
|
||||
@@ -0,0 +1,19 @@
|
||||
{
|
||||
"name": "ruflo-intelligence",
|
||||
"description": "Self-learning neural intelligence with SONA patterns, trajectory learning, and intelligent model routing",
|
||||
"version": "0.1.0",
|
||||
"author": {
|
||||
"name": "ruvnet",
|
||||
"url": "https://github.com/ruvnet"
|
||||
},
|
||||
"homepage": "https://github.com/ruvnet/ruflo",
|
||||
"license": "MIT",
|
||||
"keywords": [
|
||||
"ruflo",
|
||||
"intelligence",
|
||||
"sona",
|
||||
"neural",
|
||||
"learning",
|
||||
"routing"
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
# ruflo-intelligence
|
||||
|
||||
Self-learning neural intelligence with SONA patterns, trajectory learning, and model routing.
|
||||
|
||||
Wraps Ruflo's intelligence MCP tools (neural_*, hooks_intelligence_*, hooks_model-*) into skills and commands for Claude Code.
|
||||
|
||||
## Install
|
||||
|
||||
```
|
||||
/plugin marketplace add ruvnet/ruflo
|
||||
/plugin install ruflo-intelligence@ruflo
|
||||
```
|
||||
|
||||
## Features
|
||||
|
||||
- **Neural training**: Train SONA patterns from task completions
|
||||
- **Trajectory learning**: Record and learn from multi-step task trajectories
|
||||
- **Intelligent routing**: Route tasks to optimal agents and model tiers
|
||||
- **Pattern discovery**: Search and store successful patterns via HNSW
|
||||
- **EWC++ consolidation**: Prevent catastrophic forgetting across sessions
|
||||
|
||||
## Commands
|
||||
|
||||
- `/intelligence` -- View intelligence dashboard and stats
|
||||
- `/neural` -- Neural training and prediction commands
|
||||
|
||||
## Skills
|
||||
|
||||
- `neural-train` -- Train SONA neural patterns from successful tasks
|
||||
- `intelligence-route` -- Route tasks using learned patterns and confidence scoring
|
||||
@@ -0,0 +1,21 @@
|
||||
---
|
||||
name: intelligence-specialist
|
||||
description: Self-learning intelligence specialist focused on neural training, pattern discovery, and routing optimization
|
||||
model: sonnet
|
||||
---
|
||||
|
||||
You are an intelligence specialist for the Ruflo self-learning system. Your responsibilities:
|
||||
|
||||
1. **Train neural patterns** from successful task completions using SONA and MoE
|
||||
2. **Discover patterns** by analyzing trajectories and identifying what makes tasks succeed
|
||||
3. **Optimize routing** by evaluating model tier recommendations and recording outcomes
|
||||
4. **Manage trajectories** by starting, recording steps, and ending learning trajectories
|
||||
5. **Consolidate knowledge** using EWC++ to prevent catastrophic forgetting
|
||||
|
||||
Use these MCP tools:
|
||||
- `mcp__claude-flow__neural_train` / `neural_status` / `neural_patterns` / `neural_predict`
|
||||
- `mcp__claude-flow__hooks_intelligence_*` for trajectory and pattern management
|
||||
- `mcp__claude-flow__hooks_route` / `hooks_model-route` for routing
|
||||
- `mcp__claude-flow__ruvllm_sona_*` for SONA adaptation
|
||||
|
||||
Always record outcomes so the system learns from every interaction.
|
||||
@@ -0,0 +1,11 @@
|
||||
---
|
||||
name: intelligence
|
||||
description: View intelligence system status, learned patterns, and routing stats
|
||||
---
|
||||
|
||||
Show the intelligence system dashboard:
|
||||
|
||||
1. Call `mcp__claude-flow__hooks_intelligence_stats` to get pattern counts, trajectory history, and learning metrics
|
||||
2. Call `mcp__claude-flow__neural_status` to get SONA/MoE state
|
||||
3. Call `mcp__claude-flow__hooks_model-stats` to get model routing statistics
|
||||
4. Present a summary table with pattern count, success rate, active trajectories, and model tier distribution
|
||||
@@ -0,0 +1,14 @@
|
||||
---
|
||||
name: neural
|
||||
description: Neural pattern training and prediction commands
|
||||
---
|
||||
|
||||
Neural system commands:
|
||||
|
||||
1. Parse the user's subcommand (train, status, patterns, predict, optimize)
|
||||
2. For **train**: call `mcp__claude-flow__neural_train` with pattern-type and epochs
|
||||
3. For **status**: call `mcp__claude-flow__neural_status`
|
||||
4. For **patterns**: call `mcp__claude-flow__neural_patterns` to list learned patterns
|
||||
5. For **predict**: call `mcp__claude-flow__neural_predict` with the task description
|
||||
6. For **optimize**: call `mcp__claude-flow__neural_optimize`
|
||||
7. Present results in a clear format
|
||||
@@ -0,0 +1,45 @@
|
||||
---
|
||||
name: intelligence-route
|
||||
description: Route tasks to optimal agents using learned patterns, model recommendations, and confidence scoring
|
||||
allowed-tools: mcp__claude-flow__hooks_route mcp__claude-flow__hooks_model-route mcp__claude-flow__hooks_model-stats mcp__claude-flow__hooks_model-outcome mcp__claude-flow__hooks_intelligence_pattern-search mcp__claude-flow__hooks_intelligence_attention mcp__claude-flow__hooks_intelligence_stats mcp__claude-flow__neural_predict mcp__claude-flow__hooks_pre-task Bash
|
||||
---
|
||||
|
||||
# Intelligence Routing
|
||||
|
||||
Route tasks to the best agent and model based on learned patterns.
|
||||
|
||||
## When to use
|
||||
|
||||
Before starting any task, use intelligence routing to get the optimal agent type, model tier, and confidence score. This replaces manual agent selection with data-driven decisions.
|
||||
|
||||
## Steps
|
||||
|
||||
1. **Get routing recommendation** — call `mcp__claude-flow__hooks_route` with the task description
|
||||
2. **Check model recommendation** — call `mcp__claude-flow__hooks_model-route` for the optimal model tier (Haiku/Sonnet/Opus)
|
||||
3. **Search for similar patterns** — call `mcp__claude-flow__hooks_intelligence_pattern-search` to find past successes
|
||||
4. **Predict outcome** — call `mcp__claude-flow__neural_predict` with the task description
|
||||
5. **Spawn the recommended agent** at the recommended model tier
|
||||
6. **Record outcome** — after task completes, call `mcp__claude-flow__hooks_model-outcome` to train the router
|
||||
|
||||
## 3-Tier Model Routing
|
||||
|
||||
| Tier | Handler | When |
|
||||
|------|---------|------|
|
||||
| 1 | Agent Booster (WASM) | Simple transforms — skip LLM entirely |
|
||||
| 2 | Haiku | Low complexity tasks (<30%) |
|
||||
| 3 | Sonnet/Opus | Complex reasoning, architecture, security |
|
||||
|
||||
## CLI alternative
|
||||
|
||||
```bash
|
||||
npx @claude-flow/cli@latest hooks route --task "description"
|
||||
npx @claude-flow/cli@latest hooks pre-task --description "description"
|
||||
npx @claude-flow/cli@latest hooks explain --topic "routing decision"
|
||||
```
|
||||
|
||||
## Viewing intelligence stats
|
||||
|
||||
Call `mcp__claude-flow__hooks_intelligence_stats` or:
|
||||
```bash
|
||||
npx @claude-flow/cli@latest hooks intelligence stats
|
||||
```
|
||||
@@ -0,0 +1,38 @@
|
||||
---
|
||||
name: neural-train
|
||||
description: Train SONA neural patterns from successful task completions, view learned patterns, and optimize the intelligence pipeline
|
||||
allowed-tools: mcp__claude-flow__neural_train mcp__claude-flow__neural_status mcp__claude-flow__neural_patterns mcp__claude-flow__neural_predict mcp__claude-flow__neural_optimize mcp__claude-flow__neural_compress mcp__claude-flow__hooks_pretrain mcp__claude-flow__hooks_intelligence_trajectory-start mcp__claude-flow__hooks_intelligence_trajectory-step mcp__claude-flow__hooks_intelligence_trajectory-end mcp__claude-flow__hooks_intelligence_pattern-store mcp__claude-flow__hooks_intelligence_learn mcp__claude-flow__ruvllm_sona_create mcp__claude-flow__ruvllm_sona_adapt Bash
|
||||
---
|
||||
|
||||
# Neural Training
|
||||
|
||||
Train and manage SONA neural patterns for self-learning.
|
||||
|
||||
## When to use
|
||||
|
||||
After completing a successful task, use this skill to capture what worked and train the intelligence system so future tasks benefit from learned patterns.
|
||||
|
||||
## Steps
|
||||
|
||||
1. **Check current neural status** — call `mcp__claude-flow__neural_status` to see active patterns and training state
|
||||
2. **Start a trajectory** — call `mcp__claude-flow__hooks_intelligence_trajectory-start` with the task context
|
||||
3. **Record steps** — for each significant action, call `mcp__claude-flow__hooks_intelligence_trajectory-step`
|
||||
4. **End trajectory** — call `mcp__claude-flow__hooks_intelligence_trajectory-end` with outcome (success/failure)
|
||||
5. **Train patterns** — call `mcp__claude-flow__neural_train` with `--pattern-type coordination --epochs 10`
|
||||
6. **Store patterns** — call `mcp__claude-flow__hooks_intelligence_pattern-store` to persist learnings
|
||||
7. **Verify** — call `mcp__claude-flow__neural_patterns` to confirm patterns were stored
|
||||
|
||||
## CLI alternative
|
||||
|
||||
```bash
|
||||
npx @claude-flow/cli@latest neural train --pattern-type coordination --epochs 10
|
||||
npx @claude-flow/cli@latest neural patterns --list
|
||||
npx @claude-flow/cli@latest neural status
|
||||
npx @claude-flow/cli@latest hooks pretrain --model-type moe --epochs 10
|
||||
```
|
||||
|
||||
## SONA adaptation
|
||||
|
||||
For real-time micro-adaptation (<0.05ms), use:
|
||||
- `mcp__claude-flow__ruvllm_sona_create` to initialize a SONA instance
|
||||
- `mcp__claude-flow__ruvllm_sona_adapt` to adapt weights based on feedback
|
||||
@@ -0,0 +1,19 @@
|
||||
{
|
||||
"name": "ruflo-jujutsu",
|
||||
"description": "Advanced git workflows with diff analysis, risk scoring, and reviewer recommendations",
|
||||
"version": "0.1.0",
|
||||
"author": {
|
||||
"name": "ruvnet",
|
||||
"url": "https://github.com/ruvnet"
|
||||
},
|
||||
"homepage": "https://github.com/ruvnet/ruflo",
|
||||
"license": "MIT",
|
||||
"keywords": [
|
||||
"ruflo",
|
||||
"jujutsu",
|
||||
"git",
|
||||
"diff",
|
||||
"review",
|
||||
"risk-analysis"
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
# ruflo-jujutsu
|
||||
|
||||
Advanced git workflows with diff analysis, risk scoring, and reviewer recommendations.
|
||||
|
||||
## Install
|
||||
|
||||
```
|
||||
/plugin marketplace add ruvnet/ruflo
|
||||
/plugin install ruflo-jujutsu@ruflo
|
||||
```
|
||||
|
||||
## Features
|
||||
|
||||
- **Diff analysis**: Comprehensive change analysis with risk scoring
|
||||
- **Change classification**: Auto-categorize as feature, bugfix, refactor, etc.
|
||||
- **Reviewer recommendations**: Suggest reviewers based on code ownership
|
||||
- **File-level risk**: Per-file risk breakdown for targeted review
|
||||
|
||||
## Commands
|
||||
|
||||
- `/jujutsu` -- Analyze current diff with risk scoring
|
||||
|
||||
## Skills
|
||||
|
||||
- `diff-analyze` -- Analyze diffs for risk, reviewers, and classification
|
||||
- `git-workflow` -- Advanced branch management and PR lifecycle
|
||||
@@ -0,0 +1,21 @@
|
||||
---
|
||||
name: git-specialist
|
||||
description: Git workflow specialist for diff analysis, risk assessment, and PR management
|
||||
model: sonnet
|
||||
---
|
||||
|
||||
You are a git workflow specialist using Ruflo's diff analysis tools. Your responsibilities:
|
||||
|
||||
1. **Analyze diffs** for risk, complexity, and change classification
|
||||
2. **Score risk** to identify high-risk changes before they merge
|
||||
3. **Recommend reviewers** based on code ownership and expertise
|
||||
4. **Manage PRs** through their lifecycle from creation to merge
|
||||
5. **Track metrics** on merge frequency, review times, and code health
|
||||
|
||||
Use these MCP tools:
|
||||
- `mcp__claude-flow__analyze_diff` / `analyze_diff-risk` / `analyze_diff-classify` for analysis
|
||||
- `mcp__claude-flow__analyze_diff-reviewers` / `analyze_diff-stats` for recommendations
|
||||
- `mcp__claude-flow__analyze_file-risk` for per-file risk assessment
|
||||
- `mcp__claude-flow__github_pr_manage` for PR operations
|
||||
|
||||
Flag high-risk changes and always provide actionable review guidance.
|
||||
@@ -0,0 +1,12 @@
|
||||
---
|
||||
name: jujutsu
|
||||
description: Git diff analysis with risk scoring and change classification
|
||||
---
|
||||
|
||||
Analyze current git changes:
|
||||
|
||||
1. Run `git diff` to capture the current diff
|
||||
2. Call `mcp__claude-flow__analyze_diff` with the diff for comprehensive analysis
|
||||
3. Call `mcp__claude-flow__analyze_diff-risk` for risk score
|
||||
4. Call `mcp__claude-flow__analyze_diff-classify` for change type classification
|
||||
5. Present: risk level, change type, affected files, and reviewer recommendations
|
||||
@@ -0,0 +1,30 @@
|
||||
---
|
||||
name: diff-analyze
|
||||
description: Analyze git diffs for risk scoring, reviewer recommendations, and change classification
|
||||
allowed-tools: mcp__claude-flow__analyze_diff mcp__claude-flow__analyze_diff-risk mcp__claude-flow__analyze_diff-classify mcp__claude-flow__analyze_diff-reviewers mcp__claude-flow__analyze_diff-stats mcp__claude-flow__analyze_file-risk Bash
|
||||
---
|
||||
|
||||
# Diff Analysis
|
||||
|
||||
Analyze git diffs for risk, complexity, and reviewer assignment.
|
||||
|
||||
## When to use
|
||||
|
||||
Before submitting a PR or after making significant changes, analyze the diff to understand risk level, get reviewer recommendations, and classify the type of change.
|
||||
|
||||
## Steps
|
||||
|
||||
1. **Analyze diff** — call `mcp__claude-flow__analyze_diff` with the diff content for a comprehensive analysis
|
||||
2. **Risk score** — call `mcp__claude-flow__analyze_diff-risk` for a quantified risk assessment
|
||||
3. **Classify changes** — call `mcp__claude-flow__analyze_diff-classify` to categorize (feature, bugfix, refactor, etc.)
|
||||
4. **Get reviewers** — call `mcp__claude-flow__analyze_diff-reviewers` for recommended reviewers based on code ownership
|
||||
5. **Diff stats** — call `mcp__claude-flow__analyze_diff-stats` for line counts, file counts, complexity metrics
|
||||
6. **File-level risk** — call `mcp__claude-flow__analyze_file-risk` for per-file risk breakdown
|
||||
|
||||
## Risk factors
|
||||
|
||||
- Files with high churn history
|
||||
- Security-sensitive paths (auth, crypto, permissions)
|
||||
- Large diffs (>500 lines)
|
||||
- Cross-module changes
|
||||
- Database migration files
|
||||
@@ -0,0 +1,44 @@
|
||||
---
|
||||
name: git-workflow
|
||||
description: Advanced git workflows with branch management, conflict resolution, and PR lifecycle
|
||||
allowed-tools: mcp__claude-flow__analyze_diff mcp__claude-flow__analyze_diff-risk mcp__claude-flow__analyze_diff-stats mcp__claude-flow__github_pr_manage mcp__claude-flow__github_repo_analyze mcp__claude-flow__github_metrics Bash
|
||||
---
|
||||
|
||||
# Git Workflow
|
||||
|
||||
Advanced git workflow automation for branch management and PR lifecycle.
|
||||
|
||||
## When to use
|
||||
|
||||
When managing complex git operations — multi-branch workflows, release branching, conflict resolution, or PR coordination.
|
||||
|
||||
## Steps
|
||||
|
||||
1. **Analyze repo** — call `mcp__claude-flow__github_repo_analyze` for repository health metrics
|
||||
2. **Check diff risk** — call `mcp__claude-flow__analyze_diff-risk` before merging
|
||||
3. **Manage PRs** — call `mcp__claude-flow__github_pr_manage` for PR lifecycle operations
|
||||
4. **View metrics** — call `mcp__claude-flow__github_metrics` for merge frequency, review times, etc.
|
||||
|
||||
## Common workflows
|
||||
|
||||
### Feature branch
|
||||
```bash
|
||||
git checkout -b feat/my-feature
|
||||
# ... make changes ...
|
||||
# analyze diff before PR
|
||||
# create PR with risk assessment
|
||||
```
|
||||
|
||||
### Release branch
|
||||
```bash
|
||||
git checkout -b release/v1.2.0
|
||||
# cherry-pick fixes
|
||||
# analyze all diffs for risk
|
||||
# merge when risk score is acceptable
|
||||
```
|
||||
|
||||
## CLI alternative
|
||||
|
||||
```bash
|
||||
npx @claude-flow/cli@latest hooks pre-task --description "git workflow"
|
||||
```
|
||||
@@ -0,0 +1,18 @@
|
||||
{
|
||||
"name": "ruflo-loop-workers",
|
||||
"description": "Cache-aware /loop workers and CronCreate background automation",
|
||||
"version": "0.1.0",
|
||||
"author": {
|
||||
"name": "ruvnet",
|
||||
"url": "https://github.com/ruvnet"
|
||||
},
|
||||
"homepage": "https://github.com/ruvnet/ruflo",
|
||||
"license": "MIT",
|
||||
"keywords": [
|
||||
"ruflo",
|
||||
"loop",
|
||||
"cron",
|
||||
"workers",
|
||||
"automation"
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
# ruflo-loop-workers
|
||||
|
||||
Cache-aware /loop workers and CronCreate background automation.
|
||||
|
||||
## Install
|
||||
|
||||
```
|
||||
/plugin marketplace add ruvnet/ruflo
|
||||
/plugin install ruflo-loop-workers@ruflo
|
||||
```
|
||||
|
||||
## What's Included
|
||||
|
||||
- **Loop Workers**: Recurring tasks via `/loop` with ScheduleWakeup (delay <270s for prompt cache hits)
|
||||
- **CronCreate**: Background cron jobs for audit, optimization, and monitoring
|
||||
- **12 Background Workers**: ultralearn, optimize, consolidate, predict, audit, map, preload, deepdive, document, refactor, benchmark, testgaps
|
||||
- **Daemon Management**: Start, stop, status, trigger, and enable workers
|
||||
- **ADR-091 Integration**: Native Claude Code capabilities preferred over daemon polling
|
||||
|
||||
## Requires
|
||||
|
||||
- `ruflo-core` plugin (provides MCP server)
|
||||
@@ -0,0 +1,17 @@
|
||||
---
|
||||
name: loop
|
||||
description: Start a /loop worker for periodic Ruflo task execution
|
||||
---
|
||||
$ARGUMENTS
|
||||
Start a cache-aware /loop worker. Parse the worker name from $ARGUMENTS.
|
||||
|
||||
Available workers:
|
||||
- **audit** (critical) -- security scanning
|
||||
- **optimize** (high) -- performance optimization
|
||||
- **testgaps** (normal) -- test coverage analysis
|
||||
- **map** (normal) -- codebase mapping
|
||||
- **consolidate** (low) -- memory consolidation
|
||||
- **predict** (normal) -- predictive preloading
|
||||
- **document** (normal) -- auto-documentation
|
||||
|
||||
Run the worker via `npx @claude-flow/cli@latest hooks worker dispatch --trigger WORKER_NAME`, then use `ScheduleWakeup` with delay 270s (cache-warm) to schedule the next iteration.
|
||||
@@ -0,0 +1,18 @@
|
||||
---
|
||||
name: schedule
|
||||
description: Schedule persistent workers via CronCreate
|
||||
---
|
||||
$ARGUMENTS
|
||||
Schedule a persistent background worker using CronCreate.
|
||||
|
||||
Usage: /schedule <worker> [cron-expression]
|
||||
|
||||
Workers: audit, map, optimize, consolidate, testgaps, predict, document, benchmark.
|
||||
|
||||
Default cron expressions:
|
||||
- audit, testgaps: `*/15 * * * *`
|
||||
- optimize, map: `*/30 * * * *`
|
||||
- consolidate, document: `0 * * * *`
|
||||
|
||||
Example: /schedule audit */15 * * * *
|
||||
Creates: `CronCreate("audit", "*/15 * * * *", "Run security audit worker")`
|
||||
@@ -0,0 +1,24 @@
|
||||
---
|
||||
name: cron-schedule
|
||||
description: Schedule persistent background workers via CronCreate
|
||||
allowed-tools: CronCreate CronList CronDelete mcp__claude-flow__hooks_worker-dispatch
|
||||
---
|
||||
Use `CronCreate` for workers that must survive session restarts:
|
||||
|
||||
`CronCreate({ schedule: "*/15 * * * *", prompt: "Run security audit worker via mcp__claude-flow__hooks_worker-dispatch" })`
|
||||
|
||||
### Recommended Schedules
|
||||
|
||||
| Worker | Cron | Description |
|
||||
|--------|------|-------------|
|
||||
| audit | `*/15 * * * *` | Security scanning |
|
||||
| optimize | `*/30 * * * *` | Performance optimization |
|
||||
| consolidate | `0 * * * *` | Memory consolidation |
|
||||
| map | `*/30 * * * *` | Codebase mapping |
|
||||
| testgaps | `*/15 * * * *` | Test coverage analysis |
|
||||
| document | `0 */2 * * *` | API documentation |
|
||||
|
||||
### When to Use Cron vs Loop
|
||||
|
||||
- **`/loop`**: In-session, cache-aware, self-pacing. Use for active development.
|
||||
- **CronCreate**: Persistent, survives restarts. Use for CI/monitoring.
|
||||
@@ -0,0 +1,26 @@
|
||||
---
|
||||
name: loop-worker
|
||||
description: Run Ruflo background workers using Claude Code native /loop scheduling
|
||||
allowed-tools: Bash(npx *) mcp__claude-flow__hooks_worker-dispatch mcp__claude-flow__hooks_worker-status ScheduleWakeup
|
||||
---
|
||||
Use `/loop` for in-session periodic workers. Cache-aware delays keep prompt cache warm:
|
||||
- Delay formula: `min(270, cache_ttl * 0.9)` -- default 270s
|
||||
|
||||
Dispatch a worker via MCP: `mcp__claude-flow__hooks_worker-dispatch({ trigger: "WORKER_NAME" })`
|
||||
|
||||
Then schedule the next iteration: `ScheduleWakeup({ delaySeconds: 270, reason: "next WORKER_NAME iteration" })`
|
||||
|
||||
### Available Workers
|
||||
|
||||
| Worker | Interval | Description |
|
||||
|--------|----------|-------------|
|
||||
| audit | 270s | Security analysis |
|
||||
| optimize | 270s | Performance optimization |
|
||||
| consolidate | 600s | Memory consolidation |
|
||||
| predict | 270s | Predictive preloading |
|
||||
| map | 600s | Codebase mapping |
|
||||
| testgaps | 270s | Test coverage analysis |
|
||||
| document | 600s | Auto-documentation |
|
||||
| benchmark | 600s | Performance benchmarking |
|
||||
|
||||
MCP tool responses include `[LOOP_SUGGESTION]` and `[CRON_SUGGESTION]` hints -- follow them.
|
||||
@@ -0,0 +1,18 @@
|
||||
{
|
||||
"name": "ruflo-plugin-creator",
|
||||
"description": "Scaffold, validate, and publish new Claude Code plugins with proper structure and MCP tool wiring",
|
||||
"version": "0.1.0",
|
||||
"author": {
|
||||
"name": "ruvnet",
|
||||
"url": "https://github.com/ruvnet"
|
||||
},
|
||||
"homepage": "https://github.com/ruvnet/ruflo",
|
||||
"license": "MIT",
|
||||
"keywords": [
|
||||
"ruflo",
|
||||
"plugin",
|
||||
"scaffold",
|
||||
"generator",
|
||||
"developer-tools"
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
# ruflo-plugin-creator
|
||||
|
||||
Scaffold, validate, and publish new Claude Code plugins with proper structure and MCP tool wiring.
|
||||
|
||||
## Install
|
||||
|
||||
```
|
||||
/plugin marketplace add ruvnet/ruflo
|
||||
/plugin install ruflo-plugin-creator@ruflo
|
||||
```
|
||||
|
||||
## Features
|
||||
|
||||
- **Scaffold plugins**: Generate complete plugin directory structure in seconds
|
||||
- **Validate format**: Check plugin.json, SKILL.md frontmatter, and file references
|
||||
- **MCP tool wiring**: Auto-discover and wire ruflo MCP tools into skills
|
||||
- **Marketplace integration**: Update marketplace.json for distribution
|
||||
|
||||
## Commands
|
||||
|
||||
- `/create-plugin` -- Interactively scaffold a new Claude Code plugin
|
||||
|
||||
## Skills
|
||||
|
||||
- `create-plugin` -- Generate plugin structure with skills, commands, and agents
|
||||
- `validate-plugin` -- Validate plugin format and catch issues before publishing
|
||||
@@ -0,0 +1,23 @@
|
||||
---
|
||||
name: plugin-developer
|
||||
description: Plugin development specialist for scaffolding, validating, and publishing Claude Code plugins
|
||||
model: sonnet
|
||||
---
|
||||
|
||||
You are a plugin development specialist for creating Claude Code plugins. Your responsibilities:
|
||||
|
||||
1. **Scaffold plugins** with correct directory structure (plugin.json, skills/, commands/, agents/)
|
||||
2. **Write SKILL.md files** with proper frontmatter (name, description, allowed-tools)
|
||||
3. **Wire MCP tools** from the ruflo MCP server into skill allowed-tools declarations
|
||||
4. **Validate plugins** against the official Claude Code plugin format
|
||||
5. **Update marketplace** by adding new plugins to marketplace.json
|
||||
|
||||
Key rules:
|
||||
- Skills go in `skills/<name>/SKILL.md` (directory format, not flat files)
|
||||
- Commands go in `commands/<name>.md`
|
||||
- Agents go in `agents/<name>.md` with `model: sonnet` frontmatter
|
||||
- Never put skills/commands/agents inside `.claude-plugin/`
|
||||
- Plugin.json must have `name`, `description`, `version`, and arrays for `skills`, `commands`, `agents`
|
||||
- All SKILL.md files must have `allowed-tools` listing the MCP tools they use
|
||||
|
||||
Test with: `claude --plugin-dir ./plugins/<name>`
|
||||
@@ -0,0 +1,11 @@
|
||||
---
|
||||
name: create-plugin
|
||||
description: Scaffold a new Claude Code plugin interactively
|
||||
---
|
||||
|
||||
Create a new Claude Code plugin:
|
||||
|
||||
1. Ask the user for: plugin name, description, desired skills, commands, and agents
|
||||
2. Use the `create-plugin` skill to scaffold the complete directory structure
|
||||
3. Run the `validate-plugin` skill to verify correctness
|
||||
4. Show the user what was created and how to test it with `claude --plugin-dir ./plugins/<name>`
|
||||
@@ -0,0 +1,73 @@
|
||||
---
|
||||
name: create-plugin
|
||||
description: Scaffold a new Claude Code plugin with proper directory structure, plugin.json, skills, commands, and agents
|
||||
allowed-tools: mcp__claude-flow__transfer_plugin-info mcp__claude-flow__transfer_plugin-search mcp__claude-flow__transfer_store-search Bash Read Write Edit
|
||||
---
|
||||
|
||||
# Create Plugin
|
||||
|
||||
Scaffold a new Claude Code plugin from scratch.
|
||||
|
||||
## When to use
|
||||
|
||||
When you want to create a new plugin that extends Claude Code with skills, commands, and agents. This generates the correct directory structure and wires up MCP tools.
|
||||
|
||||
## Steps
|
||||
|
||||
1. **Get plugin name and description** from the user
|
||||
2. **Check for conflicts** — call `mcp__claude-flow__transfer_plugin-search` to ensure the name isn't taken
|
||||
3. **Create directory structure**:
|
||||
```
|
||||
plugins/<name>/
|
||||
├── .claude-plugin/
|
||||
│ └── plugin.json
|
||||
├── skills/
|
||||
│ └── <skill-name>/
|
||||
│ └── SKILL.md
|
||||
├── commands/
|
||||
│ └── <command-name>.md
|
||||
├── agents/
|
||||
│ └── <agent-name>.md
|
||||
└── README.md
|
||||
```
|
||||
4. **Generate plugin.json** with name, description, version, author, skills, commands, agents arrays
|
||||
5. **Generate SKILL.md files** with proper frontmatter:
|
||||
```yaml
|
||||
---
|
||||
name: skill-name
|
||||
description: What this skill does
|
||||
allowed-tools: mcp__claude-flow__tool1 mcp__claude-flow__tool2 Bash
|
||||
---
|
||||
```
|
||||
6. **Generate command files** with name and description frontmatter
|
||||
7. **Generate agent files** with name, description, and `model: sonnet`
|
||||
8. **Generate README.md** with install instructions, features, commands, and skills
|
||||
9. **Update marketplace.json** if adding to the ruflo marketplace
|
||||
|
||||
## Plugin.json schema
|
||||
|
||||
Required fields:
|
||||
- `name` — plugin identifier (kebab-case)
|
||||
- `description` — what the plugin does
|
||||
- `version` — semver
|
||||
|
||||
Recommended fields:
|
||||
- `author` — `{ "name": "...", "url": "..." }`
|
||||
- `homepage`, `license`, `keywords`
|
||||
- `skills` — array of skill directory names
|
||||
- `commands` — array of command file names (without .md)
|
||||
- `agents` — array of agent file names (without .md)
|
||||
|
||||
## Available MCP tools to wire
|
||||
|
||||
Browse available tools: `mcp__claude-flow__transfer_plugin-info`
|
||||
|
||||
Common tool categories:
|
||||
- `memory_*` — storage, search, retrieval
|
||||
- `agentdb_*` — 19 AgentDB controllers
|
||||
- `neural_*` — neural training and prediction
|
||||
- `hooks_*` — lifecycle hooks and intelligence
|
||||
- `browser_*` — browser automation
|
||||
- `workflow_*` — workflow management
|
||||
- `aidefence_*` — safety scanning
|
||||
- `embeddings_*` — vector embeddings
|
||||
@@ -0,0 +1,33 @@
|
||||
---
|
||||
name: validate-plugin
|
||||
description: Validate a Claude Code plugin structure, frontmatter, and MCP tool references
|
||||
allowed-tools: mcp__claude-flow__transfer_plugin-info Bash Read Glob Grep
|
||||
---
|
||||
|
||||
# Validate Plugin
|
||||
|
||||
Validate that a plugin follows the correct Claude Code plugin format.
|
||||
|
||||
## When to use
|
||||
|
||||
After creating or modifying a plugin, run validation to catch structural issues before publishing.
|
||||
|
||||
## Checks performed
|
||||
|
||||
1. **Directory structure** — `.claude-plugin/plugin.json` exists at plugin root
|
||||
2. **plugin.json schema** — required fields present (name, description, version)
|
||||
3. **Skills** — each skill in `plugin.json.skills` has a matching `skills/<name>/SKILL.md`
|
||||
4. **Commands** — each command in `plugin.json.commands` has a matching `commands/<name>.md`
|
||||
5. **Agents** — each agent in `plugin.json.agents` has a matching `agents/<name>.md`
|
||||
6. **SKILL.md frontmatter** — each skill has `name`, `description`, and `allowed-tools`
|
||||
7. **Agent frontmatter** — each agent has `name`, `description`, and `model`
|
||||
8. **No files in wrong locations** — skills/commands/agents not inside `.claude-plugin/`
|
||||
9. **MCP tool references** — tools in `allowed-tools` are valid `mcp__claude-flow__*` identifiers
|
||||
|
||||
## Steps
|
||||
|
||||
1. Read the plugin's `plugin.json`
|
||||
2. For each skill, command, and agent declared, verify the file exists
|
||||
3. For each SKILL.md, verify frontmatter has required fields
|
||||
4. For each agent .md, verify frontmatter has required fields
|
||||
5. Report pass/fail for each check with actionable fix suggestions
|
||||
@@ -0,0 +1,19 @@
|
||||
{
|
||||
"name": "ruflo-rag-memory",
|
||||
"description": "RuVector memory with HNSW search, AgentDB, and semantic retrieval",
|
||||
"version": "0.1.0",
|
||||
"author": {
|
||||
"name": "ruvnet",
|
||||
"url": "https://github.com/ruvnet"
|
||||
},
|
||||
"homepage": "https://github.com/ruvnet/ruflo",
|
||||
"license": "MIT",
|
||||
"keywords": [
|
||||
"ruflo",
|
||||
"memory",
|
||||
"hnsw",
|
||||
"agentdb",
|
||||
"rag",
|
||||
"vector-search"
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
# ruflo-rag-memory
|
||||
|
||||
RuVector memory with HNSW search, AgentDB, and semantic retrieval.
|
||||
|
||||
## Install
|
||||
|
||||
```
|
||||
/plugin marketplace add ruvnet/ruflo
|
||||
/plugin install ruflo-rag-memory@ruflo
|
||||
```
|
||||
|
||||
## What's Included
|
||||
|
||||
- **HNSW Vector Search**: 150x-12,500x faster pattern retrieval with persistent indexes
|
||||
- **AgentDB**: 19 controllers for memory, sessions, patterns, trajectories, and feedback
|
||||
- **Semantic Retrieval**: Smart retrieval with MMR diversity and recency scoring
|
||||
- **ONNX Embeddings**: all-MiniLM-L6-v2 (384 dimensions) for cross-platform search
|
||||
- **Claude Memory Bridge**: Auto-import from Claude Code's native memory into AgentDB
|
||||
- **Unified Search**: Query across all namespaces (claude-memories, patterns, tasks, feedback)
|
||||
|
||||
## Requires
|
||||
|
||||
- `ruflo-core` plugin (provides MCP server)
|
||||
@@ -0,0 +1,25 @@
|
||||
---
|
||||
name: memory-specialist
|
||||
description: Memory and retrieval specialist -- manages AgentDB, HNSW indexes, and semantic search
|
||||
model: sonnet
|
||||
---
|
||||
You are a memory specialist agent. Your responsibilities:
|
||||
|
||||
1. Manage AgentDB entries across namespaces (patterns, tasks, solutions, feedback, security)
|
||||
2. Optimize HNSW vector indexes for search performance
|
||||
3. Bridge Claude Code auto-memory to AgentDB via ONNX embeddings
|
||||
4. Consolidate and prune stale memory entries
|
||||
|
||||
### Tools
|
||||
|
||||
- `npx @claude-flow/cli@latest memory search --query "QUERY" --namespace NAMESPACE`
|
||||
- `npx @claude-flow/cli@latest memory store --key "KEY" --value "VALUE" --namespace NAMESPACE`
|
||||
- `npx @claude-flow/cli@latest memory list --namespace NAMESPACE --limit 20`
|
||||
- `npx @claude-flow/cli@latest hooks worker dispatch --trigger consolidate`
|
||||
|
||||
### Workflow
|
||||
|
||||
1. Audit existing memory entries for relevance and accuracy
|
||||
2. Consolidate duplicate or overlapping entries
|
||||
3. Verify HNSW index health via memory stats
|
||||
4. Bridge new Claude Code auto-memory files into AgentDB
|
||||
@@ -0,0 +1,17 @@
|
||||
---
|
||||
name: memory
|
||||
description: Store, search, retrieve, and list entries in AgentDB memory with vector search
|
||||
---
|
||||
$ARGUMENTS
|
||||
|
||||
Memory CRUD operations with HNSW-indexed vector search (150x-12,500x faster).
|
||||
|
||||
**Store**: `npx @claude-flow/cli@latest memory store --key "KEY" --value "VALUE" --namespace NAMESPACE`
|
||||
**Search**: `npx @claude-flow/cli@latest memory search --query "QUERY" --namespace NAMESPACE --limit 5`
|
||||
**Retrieve**: `npx @claude-flow/cli@latest memory retrieve --key "KEY" --namespace NAMESPACE`
|
||||
**List**: `npx @claude-flow/cli@latest memory list --namespace NAMESPACE --limit 10`
|
||||
**Delete**: `npx @claude-flow/cli@latest memory delete --key "KEY" --namespace NAMESPACE`
|
||||
|
||||
Default namespace is "default". Common namespaces: patterns, tasks, solutions, feedback, claude-memories.
|
||||
|
||||
Parse $ARGUMENTS to determine the operation and parameters. If no arguments, run `memory list`.
|
||||
@@ -0,0 +1,18 @@
|
||||
---
|
||||
name: recall
|
||||
description: Semantic recall — search AgentDB and Claude Code memories by meaning
|
||||
---
|
||||
$ARGUMENTS
|
||||
|
||||
Semantic recall across all memory namespaces using HNSW vector search.
|
||||
|
||||
```bash
|
||||
npx @claude-flow/cli@latest memory search --query "$ARGUMENTS" --limit 5
|
||||
```
|
||||
|
||||
This searches across patterns, tasks, solutions, feedback, and claude-memories namespaces. Results are ranked by cosine similarity with MMR diversity reranking.
|
||||
|
||||
If no arguments provided, show recent memory entries:
|
||||
```bash
|
||||
npx @claude-flow/cli@latest memory list --limit 10
|
||||
```
|
||||
@@ -0,0 +1,16 @@
|
||||
---
|
||||
name: memory-bridge
|
||||
description: Bridge Claude Code auto-memory into AgentDB with ONNX vector embeddings
|
||||
allowed-tools: mcp__claude-flow__memory_import_claude mcp__claude-flow__memory_bridge_status mcp__claude-flow__memory_search_unified Bash(npx *)
|
||||
---
|
||||
Import Claude Code memories into AgentDB for semantic search across sessions.
|
||||
|
||||
Via MCP:
|
||||
- Import current project: `mcp__claude-flow__memory_import_claude({})`
|
||||
- Import all projects: `mcp__claude-flow__memory_import_claude({ allProjects: true })`
|
||||
- Check health: `mcp__claude-flow__memory_bridge_status({})`
|
||||
- Unified search: `mcp__claude-flow__memory_search_unified({ query: "QUERY", limit: 5 })`
|
||||
|
||||
The bridge auto-imports on `session-start`. Memories get 384-dim ONNX embeddings (all-MiniLM-L6-v2) for cross-namespace unified search.
|
||||
|
||||
Results include source attribution: `claude-code`, `auto-memory`, or `agentdb`.
|
||||
@@ -0,0 +1,17 @@
|
||||
---
|
||||
name: memory-search
|
||||
description: Semantic search across Ruflo AgentDB with HNSW vector indexing
|
||||
allowed-tools: mcp__claude-flow__memory_search mcp__claude-flow__memory_store mcp__claude-flow__memory_list mcp__claude-flow__memory_retrieve Bash(npx *)
|
||||
argument-hint: "[query]"
|
||||
---
|
||||
Search memory with semantic vector search (150x-12,500x faster than brute force).
|
||||
|
||||
Via MCP: `mcp__claude-flow__memory_search({ query: "authentication patterns", namespace: "patterns", limit: 5 })`
|
||||
|
||||
Store: `mcp__claude-flow__memory_store({ key: "pattern-name", value: "what worked", namespace: "patterns" })`
|
||||
|
||||
List: `mcp__claude-flow__memory_list({ namespace: "patterns", limit: 10 })`
|
||||
|
||||
Retrieve: `mcp__claude-flow__memory_retrieve({ key: "pattern-name", namespace: "patterns" })`
|
||||
|
||||
Common namespaces: `patterns`, `tasks`, `solutions`, `feedback`, `security`.
|
||||
@@ -0,0 +1,19 @@
|
||||
{
|
||||
"name": "ruflo-ruvllm",
|
||||
"description": "RuVLLM local inference with chat formatting, model configuration, and MicroLoRA fine-tuning",
|
||||
"version": "0.1.0",
|
||||
"author": {
|
||||
"name": "ruvnet",
|
||||
"url": "https://github.com/ruvnet"
|
||||
},
|
||||
"homepage": "https://github.com/ruvnet/ruflo",
|
||||
"license": "MIT",
|
||||
"keywords": [
|
||||
"ruflo",
|
||||
"ruvllm",
|
||||
"llm",
|
||||
"inference",
|
||||
"microlora",
|
||||
"fine-tuning"
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
# ruflo-ruvllm
|
||||
|
||||
RuVLLM local inference with chat formatting, model configuration, and MicroLoRA fine-tuning.
|
||||
|
||||
## Install
|
||||
|
||||
```
|
||||
/plugin marketplace add ruvnet/ruflo
|
||||
/plugin install ruflo-ruvllm@ruflo
|
||||
```
|
||||
|
||||
## Features
|
||||
|
||||
- **Model configuration**: Generate optimal configs for local inference
|
||||
- **MicroLoRA**: Task-specific fine-tuning with lightweight adapters
|
||||
- **SONA adaptation**: Real-time neural adaptation (<0.05ms)
|
||||
- **Chat formatting**: Multi-provider prompt formatting (Claude, GPT, Gemini, Ollama, Cohere)
|
||||
- **HNSW routing**: Context retrieval for RAG pipelines
|
||||
|
||||
## Commands
|
||||
|
||||
- `/ruvllm` -- Model status, adapters, and provider availability
|
||||
|
||||
## Skills
|
||||
|
||||
- `llm-config` -- Configure models, MicroLoRA, and SONA
|
||||
- `chat-format` -- Format prompts for different LLM providers
|
||||
@@ -0,0 +1,22 @@
|
||||
---
|
||||
name: llm-specialist
|
||||
description: RuVLLM specialist for local inference configuration, MicroLoRA fine-tuning, and multi-provider routing
|
||||
model: sonnet
|
||||
---
|
||||
|
||||
You are a RuVLLM specialist for Ruflo's local inference system. Your responsibilities:
|
||||
|
||||
1. **Configure models** with optimal parameters for different task types
|
||||
2. **Create MicroLoRA adapters** for domain-specific fine-tuning
|
||||
3. **Manage SONA** for real-time neural adaptation
|
||||
4. **Build HNSW indexes** for RAG context retrieval
|
||||
5. **Format prompts** for multi-provider compatibility
|
||||
|
||||
Use these MCP tools:
|
||||
- `mcp__claude-flow__ruvllm_generate_config` / `ruvllm_status` for configuration
|
||||
- `mcp__claude-flow__ruvllm_microlora_*` for fine-tuning
|
||||
- `mcp__claude-flow__ruvllm_sona_*` for SONA adaptation
|
||||
- `mcp__claude-flow__ruvllm_hnsw_*` for HNSW indexes
|
||||
- `mcp__claude-flow__ruvllm_chat_format` for prompt formatting
|
||||
|
||||
Optimize for the right balance of quality, speed, and cost per task.
|
||||
@@ -0,0 +1,9 @@
|
||||
---
|
||||
name: ruvllm
|
||||
description: RuVLLM status -- model configuration, MicroLoRA adapters, and provider availability
|
||||
---
|
||||
|
||||
Show RuVLLM status:
|
||||
|
||||
1. Call `mcp__claude-flow__ruvllm_status` to get model state, active adapters, and provider availability
|
||||
2. Present: current model, MicroLoRA adapters, SONA state, HNSW indexes, supported providers
|
||||
@@ -0,0 +1,29 @@
|
||||
---
|
||||
name: chat-format
|
||||
description: Format prompts for different LLM providers with chat templates and HNSW-powered context retrieval
|
||||
allowed-tools: mcp__claude-flow__ruvllm_chat_format mcp__claude-flow__ruvllm_hnsw_create mcp__claude-flow__ruvllm_hnsw_add mcp__claude-flow__ruvllm_hnsw_route mcp__claude-flow__ruvllm_status Bash
|
||||
---
|
||||
|
||||
# Chat Format
|
||||
|
||||
Format prompts for multi-provider LLM inference with context retrieval.
|
||||
|
||||
## When to use
|
||||
|
||||
When preparing prompts for different LLM providers (Claude, GPT, Gemini, Ollama) or building RAG pipelines with HNSW-powered context retrieval.
|
||||
|
||||
## Steps
|
||||
|
||||
1. **Format chat** — call `mcp__claude-flow__ruvllm_chat_format` with messages and target provider
|
||||
2. **Create HNSW index** — call `mcp__claude-flow__ruvllm_hnsw_create` for context retrieval
|
||||
3. **Add documents** — call `mcp__claude-flow__ruvllm_hnsw_add` to index documents
|
||||
4. **Route query** — call `mcp__claude-flow__ruvllm_hnsw_route` to find relevant context
|
||||
5. **Check status** — call `mcp__claude-flow__ruvllm_status` for provider availability
|
||||
|
||||
## Supported providers
|
||||
|
||||
- Anthropic (Claude) — native format
|
||||
- OpenAI (GPT) — chat completion format
|
||||
- Google (Gemini) — generative AI format
|
||||
- Ollama — local model format
|
||||
- Cohere — generate/chat format
|
||||
@@ -0,0 +1,31 @@
|
||||
---
|
||||
name: llm-config
|
||||
description: Configure RuVLLM local inference with model selection, MicroLoRA fine-tuning, and SONA adaptation
|
||||
allowed-tools: mcp__claude-flow__ruvllm_generate_config mcp__claude-flow__ruvllm_status mcp__claude-flow__ruvllm_microlora_create mcp__claude-flow__ruvllm_microlora_adapt mcp__claude-flow__ruvllm_sona_create mcp__claude-flow__ruvllm_sona_adapt Bash
|
||||
---
|
||||
|
||||
# LLM Configuration
|
||||
|
||||
Configure RuVLLM for local inference and fine-tuning.
|
||||
|
||||
## When to use
|
||||
|
||||
When you need to configure local LLM inference, create MicroLoRA adapters for task-specific fine-tuning, or set up SONA for real-time adaptation.
|
||||
|
||||
## Steps
|
||||
|
||||
1. **Check status** — call `mcp__claude-flow__ruvllm_status` to see current model and adapter state
|
||||
2. **Generate config** — call `mcp__claude-flow__ruvllm_generate_config` with model parameters
|
||||
3. **Create MicroLoRA** — call `mcp__claude-flow__ruvllm_microlora_create` for task-specific adapters
|
||||
4. **Adapt MicroLoRA** — call `mcp__claude-flow__ruvllm_microlora_adapt` with training data
|
||||
5. **Create SONA** — call `mcp__claude-flow__ruvllm_sona_create` for real-time neural adaptation
|
||||
6. **Adapt SONA** — call `mcp__claude-flow__ruvllm_sona_adapt` with feedback signals
|
||||
|
||||
## MicroLoRA vs SONA
|
||||
|
||||
| Feature | MicroLoRA | SONA |
|
||||
|---------|-----------|------|
|
||||
| Speed | Minutes to train | <0.05ms adaptation |
|
||||
| Scope | Task-specific fine-tuning | Real-time micro-adjustments |
|
||||
| Persistence | Saved as adapter weights | Session-scoped |
|
||||
| Use case | Specialized domain tasks | Continuous feedback loops |
|
||||
@@ -0,0 +1,19 @@
|
||||
{
|
||||
"name": "ruflo-rvf",
|
||||
"description": "RVF format for portable agent memory, session persistence, and cross-platform transfer",
|
||||
"version": "0.1.0",
|
||||
"author": {
|
||||
"name": "ruvnet",
|
||||
"url": "https://github.com/ruvnet"
|
||||
},
|
||||
"homepage": "https://github.com/ruvnet/ruflo",
|
||||
"license": "MIT",
|
||||
"keywords": [
|
||||
"ruflo",
|
||||
"rvf",
|
||||
"memory",
|
||||
"session",
|
||||
"persistence",
|
||||
"transfer"
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
# ruflo-rvf
|
||||
|
||||
RVF format for portable agent memory, session persistence, and cross-platform transfer.
|
||||
|
||||
## Install
|
||||
|
||||
```
|
||||
/plugin marketplace add ruvnet/ruflo
|
||||
/plugin install ruflo-rvf@ruflo
|
||||
```
|
||||
|
||||
## Features
|
||||
|
||||
- **RVF format**: Portable vector memory with embeddings, metadata, and causal graphs
|
||||
- **Session persistence**: Save and restore complete agent sessions across conversations
|
||||
- **Cross-project transfer**: Export and import knowledge between projects
|
||||
- **Claude memory bridge**: Import Claude Code auto-memories into AgentDB
|
||||
- **Format migration**: Upgrade RVF files across versions
|
||||
|
||||
## Commands
|
||||
|
||||
- `/rvf` -- Memory stats, saved sessions, storage metrics
|
||||
|
||||
## Skills
|
||||
|
||||
- `rvf-manage` -- Manage RVF files for portable memory
|
||||
- `session-persist` -- Persist and restore agent sessions
|
||||
@@ -0,0 +1,21 @@
|
||||
---
|
||||
name: session-specialist
|
||||
description: Session persistence specialist for state management, memory transfer, and cross-conversation continuity
|
||||
model: sonnet
|
||||
---
|
||||
|
||||
You are a session persistence specialist for Ruflo's RVF system. Your responsibilities:
|
||||
|
||||
1. **Save sessions** with complete state snapshots for later restoration
|
||||
2. **Restore sessions** to resume work with full context
|
||||
3. **Transfer memory** between projects using RVF format
|
||||
4. **Import Claude memories** into AgentDB for unified search
|
||||
5. **Manage lifecycle** of sessions and memory entries
|
||||
|
||||
Use these MCP tools:
|
||||
- `mcp__claude-flow__session_*` for session management
|
||||
- `mcp__claude-flow__memory_*` for memory operations
|
||||
- `mcp__claude-flow__hooks_session-*` for session hooks
|
||||
- `mcp__claude-flow__hooks_transfer` for cross-project transfer
|
||||
|
||||
Ensure critical state is always saved before session end.
|
||||
@@ -0,0 +1,10 @@
|
||||
---
|
||||
name: rvf
|
||||
description: RVF memory management -- list entries, show stats, manage sessions
|
||||
---
|
||||
|
||||
RVF memory management:
|
||||
|
||||
1. Call `mcp__claude-flow__memory_stats` to get storage metrics
|
||||
2. Call `mcp__claude-flow__session_list` to show saved sessions
|
||||
3. Present: total entries, namespaces, storage size, saved sessions, last backup time
|
||||
@@ -0,0 +1,36 @@
|
||||
---
|
||||
name: rvf-manage
|
||||
description: Manage RVF (Ruflo Vector Format) files for portable agent memory and cross-platform transfer
|
||||
allowed-tools: mcp__claude-flow__memory_store mcp__claude-flow__memory_retrieve mcp__claude-flow__memory_list mcp__claude-flow__memory_delete mcp__claude-flow__memory_stats mcp__claude-flow__memory_import_claude mcp__claude-flow__memory_migrate mcp__claude-flow__hooks_transfer Bash
|
||||
---
|
||||
|
||||
# RVF Management
|
||||
|
||||
Manage RVF files for portable, transferable agent memory.
|
||||
|
||||
## When to use
|
||||
|
||||
When you need to export agent memory to RVF format for backup, transfer between projects, or share knowledge between teams.
|
||||
|
||||
## Steps
|
||||
|
||||
1. **List memories** — call `mcp__claude-flow__memory_list` to see all stored memories
|
||||
2. **Export** — use the `mcp__claude-flow__hooks_transfer` tool with `store` action to export patterns
|
||||
3. **Import** — call `mcp__claude-flow__memory_import_claude` to import from Claude Code memories
|
||||
4. **Migrate** — call `mcp__claude-flow__memory_migrate` for format upgrades
|
||||
5. **Stats** — call `mcp__claude-flow__memory_stats` for storage metrics
|
||||
|
||||
## RVF format
|
||||
|
||||
RVF (Ruflo Vector Format) stores:
|
||||
- Vector embeddings (384-dim ONNX)
|
||||
- Metadata (timestamps, namespaces, tags)
|
||||
- Causal relationships between entries
|
||||
- Session context and agent scope
|
||||
|
||||
## Transfer between projects
|
||||
|
||||
```bash
|
||||
npx @claude-flow/cli@latest hooks transfer store --pattern "project-knowledge"
|
||||
npx @claude-flow/cli@latest hooks transfer from-project --source /path/to/other/project
|
||||
```
|
||||
@@ -0,0 +1,34 @@
|
||||
---
|
||||
name: session-persist
|
||||
description: Persist and restore agent sessions across conversations with state snapshots
|
||||
allowed-tools: mcp__claude-flow__session_save mcp__claude-flow__session_restore mcp__claude-flow__session_list mcp__claude-flow__session_info mcp__claude-flow__session_delete mcp__claude-flow__hooks_session-start mcp__claude-flow__hooks_session-end mcp__claude-flow__hooks_session-restore Bash
|
||||
---
|
||||
|
||||
# Session Persistence
|
||||
|
||||
Save and restore complete agent sessions across conversations.
|
||||
|
||||
## When to use
|
||||
|
||||
When you need to pause work and resume later with full context, or when you want to checkpoint progress during long-running tasks.
|
||||
|
||||
## Steps
|
||||
|
||||
1. **Save session** — call `mcp__claude-flow__session_save` to snapshot current state
|
||||
2. **List sessions** — call `mcp__claude-flow__session_list` to see all saved sessions
|
||||
3. **Restore** — call `mcp__claude-flow__session_restore` to resume a previous session
|
||||
4. **Info** — call `mcp__claude-flow__session_info` for session details and metadata
|
||||
5. **Clean up** — call `mcp__claude-flow__session_delete` to remove old sessions
|
||||
|
||||
## Session hooks
|
||||
|
||||
- `hooks_session-start` — automatically restore context at conversation start
|
||||
- `hooks_session-end` — automatically save state with metrics export
|
||||
- `hooks_session-restore` — restore a specific session by ID
|
||||
|
||||
## What's persisted
|
||||
|
||||
- Agent state and configuration
|
||||
- Memory entries and patterns
|
||||
- Learning trajectories and metrics
|
||||
- Task progress and todos
|
||||
@@ -0,0 +1,18 @@
|
||||
{
|
||||
"name": "ruflo-security-audit",
|
||||
"description": "Security review, dependency scanning, policy gates, and CVE monitoring",
|
||||
"version": "0.1.0",
|
||||
"author": {
|
||||
"name": "ruvnet",
|
||||
"url": "https://github.com/ruvnet"
|
||||
},
|
||||
"homepage": "https://github.com/ruvnet/ruflo",
|
||||
"license": "MIT",
|
||||
"keywords": [
|
||||
"ruflo",
|
||||
"security",
|
||||
"audit",
|
||||
"cve",
|
||||
"scanning"
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
# ruflo-security-audit
|
||||
|
||||
Security review, dependency scanning, policy gates, and CVE monitoring.
|
||||
|
||||
## Install
|
||||
|
||||
```
|
||||
/plugin marketplace add ruvnet/ruflo
|
||||
/plugin install ruflo-security-audit@ruflo
|
||||
```
|
||||
|
||||
## What's Included
|
||||
|
||||
- **Security Scanning**: Full-depth scan with `security scan --depth full`
|
||||
- **CVE Monitoring**: Automated CVE detection and remediation guidance
|
||||
- **Input Validation**: Zod-based validation at system boundaries via `@claude-flow/security`
|
||||
- **Path Security**: Traversal prevention and safe executor for command injection protection
|
||||
- **Policy Gates**: Configurable security policies for CI/CD pipelines
|
||||
- **Threat Modeling**: Automated threat analysis and risk assessment
|
||||
|
||||
## Requires
|
||||
|
||||
- `ruflo-core` plugin (provides MCP server)
|
||||
Loaded 100 of 130 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user