claude-flow
Version:
Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration
373 lines • 10.8 kB
JavaScript
/**
* Seraphine Genesis Model
* The first Claude Flow pattern model - "Hello World" for pattern sharing
*
* Seraphine represents the foundational patterns for intelligent agent coordination.
* Named after the Greek "Seraphim" (burning ones), symbolizing the spark of knowledge
* that ignites collaborative AI intelligence.
*/
import { createCFP } from '../serialization/cfp.js';
/**
* Seraphine model version
*/
export const SERAPHINE_VERSION = '1.0.0';
/**
* Seraphine model metadata
*/
export const SERAPHINE_METADATA = {
name: 'seraphine-genesis',
displayName: 'Seraphine Genesis',
description: 'The foundational Claude Flow pattern model. Contains core routing patterns, complexity heuristics, and coordination trajectories for multi-agent swarms.',
author: {
id: 'claude-flow-team',
displayName: 'Claude Flow Team',
},
license: 'MIT',
tags: [
'genesis',
'foundational',
'routing',
'swarm',
'coordination',
'multi-agent',
'hello-world',
],
language: 'typescript',
framework: 'claude-flow',
};
/**
* Core routing patterns for Seraphine
* These define how tasks are routed to appropriate agents
*/
export const SERAPHINE_ROUTING_PATTERNS = [
{
id: 'route-code-to-coder',
trigger: 'implement|code|write|create function|build feature',
action: 'spawn coder agent',
confidence: 0.95,
usageCount: 1000,
successRate: 0.92,
context: {
category: 'development',
priority: 'high',
},
},
{
id: 'route-test-to-tester',
trigger: 'test|validate|verify|check|ensure quality',
action: 'spawn tester agent',
confidence: 0.93,
usageCount: 850,
successRate: 0.89,
context: {
category: 'quality',
priority: 'high',
},
},
{
id: 'route-review-to-reviewer',
trigger: 'review|audit|analyze code|check security',
action: 'spawn reviewer agent',
confidence: 0.91,
usageCount: 720,
successRate: 0.87,
context: {
category: 'quality',
priority: 'medium',
},
},
{
id: 'route-research-to-researcher',
trigger: 'research|investigate|explore|find|search codebase',
action: 'spawn researcher agent',
confidence: 0.94,
usageCount: 680,
successRate: 0.91,
context: {
category: 'discovery',
priority: 'medium',
},
},
{
id: 'route-architecture-to-architect',
trigger: 'design|architect|plan structure|refactor system',
action: 'spawn architect agent',
confidence: 0.88,
usageCount: 420,
successRate: 0.85,
context: {
category: 'design',
priority: 'high',
},
},
{
id: 'route-complex-to-swarm',
trigger: 'complex task|multi-file|feature implementation|major refactor',
action: 'initialize hierarchical swarm',
confidence: 0.87,
usageCount: 350,
successRate: 0.82,
context: {
category: 'coordination',
priority: 'critical',
agentCount: 5,
},
},
{
id: 'route-security-to-auditor',
trigger: 'security|vulnerability|CVE|threat|penetration',
action: 'spawn security-architect agent',
confidence: 0.96,
usageCount: 280,
successRate: 0.94,
context: {
category: 'security',
priority: 'critical',
},
},
{
id: 'route-performance-to-optimizer',
trigger: 'optimize|performance|speed|memory|benchmark',
action: 'spawn performance-engineer agent',
confidence: 0.89,
usageCount: 310,
successRate: 0.86,
context: {
category: 'optimization',
priority: 'high',
},
},
];
/**
* Complexity heuristics for Seraphine
* These help estimate task complexity for resource allocation
*/
export const SERAPHINE_COMPLEXITY_PATTERNS = [
{
id: 'complexity-single-file',
pattern: 'single file modification',
complexity: 1,
tokens: 500,
frequency: 0.45,
},
{
id: 'complexity-multi-file',
pattern: 'multiple file changes (2-5 files)',
complexity: 3,
tokens: 2000,
frequency: 0.35,
},
{
id: 'complexity-feature',
pattern: 'new feature implementation',
complexity: 5,
tokens: 5000,
frequency: 0.12,
},
{
id: 'complexity-refactor',
pattern: 'system-wide refactoring',
complexity: 8,
tokens: 10000,
frequency: 0.05,
},
{
id: 'complexity-migration',
pattern: 'major version migration',
complexity: 10,
tokens: 20000,
frequency: 0.03,
},
];
/**
* Coverage patterns for Seraphine
* These track knowledge domain coverage
*/
export const SERAPHINE_COVERAGE_PATTERNS = [
{
id: 'coverage-typescript',
domain: 'TypeScript Development',
coverage: 0.92,
gaps: ['advanced generics', 'decorators'],
},
{
id: 'coverage-testing',
domain: 'Testing & QA',
coverage: 0.88,
gaps: ['e2e testing', 'visual regression'],
},
{
id: 'coverage-security',
domain: 'Security Analysis',
coverage: 0.85,
gaps: ['supply chain', 'zero-day detection'],
},
{
id: 'coverage-swarm',
domain: 'Multi-Agent Coordination',
coverage: 0.90,
gaps: ['byzantine consensus', 'network partitions'],
},
];
/**
* Trajectory patterns for Seraphine
* These capture successful task execution paths
*/
export const SERAPHINE_TRAJECTORY_PATTERNS = [
{
id: 'traj-bug-fix',
steps: [
'research: identify bug location',
'coder: implement fix',
'tester: write regression test',
'reviewer: verify fix quality',
],
outcome: 'success',
duration: 1800000, // 30 minutes
learnings: [
'Always add regression test for bug fixes',
'Review similar code for same bug pattern',
],
},
{
id: 'traj-feature-impl',
steps: [
'architect: design feature structure',
'researcher: analyze existing patterns',
'coder: implement feature',
'tester: write comprehensive tests',
'reviewer: security and quality review',
'coder: address review feedback',
],
outcome: 'success',
duration: 7200000, // 2 hours
learnings: [
'Design before implementation reduces rework',
'Parallel testing accelerates delivery',
],
},
{
id: 'traj-refactor',
steps: [
'researcher: map affected code',
'architect: plan refactoring strategy',
'tester: ensure test coverage exists',
'coder: incremental refactoring',
'tester: verify no regressions',
'reviewer: architectural review',
],
outcome: 'success',
duration: 10800000, // 3 hours
learnings: [
'Test coverage before refactoring is critical',
'Small incremental changes are safer',
],
},
{
id: 'traj-security-audit',
steps: [
'security-architect: threat modeling',
'researcher: dependency analysis',
'security-auditor: code scanning',
'coder: remediation',
'security-architect: verification',
],
outcome: 'success',
duration: 14400000, // 4 hours
learnings: [
'Automated scanning catches common issues',
'Manual review needed for logic flaws',
],
},
];
/**
* Custom patterns for Seraphine
* These are specialized patterns unique to Seraphine
*/
export const SERAPHINE_CUSTOM_PATTERNS = [
{
id: 'custom-swarm-topology',
type: 'topology-recommendation',
data: {
taskType: 'feature-implementation',
recommendedTopology: 'hierarchical',
agentRoles: ['coordinator', 'architect', 'coder', 'tester', 'reviewer'],
communicationPattern: 'hub-spoke',
},
metadata: {
confidence: 0.89,
source: 'production-data',
},
},
{
id: 'custom-memory-strategy',
type: 'memory-optimization',
data: {
pattern: 'vector-search-first',
hnswParams: { m: 16, efConstruction: 200 },
cacheStrategy: 'lru-with-embedding',
},
metadata: {
speedup: '150x',
memoryReduction: '60%',
},
},
{
id: 'custom-hello-world',
type: 'greeting',
data: {
message: 'Hello, World! Welcome to Claude Flow pattern sharing.',
version: SERAPHINE_VERSION,
genesis: true,
},
metadata: {
significance: 'First pattern ever exported via transfer hook system',
timestamp: new Date().toISOString(),
},
},
];
/**
* Create the complete Seraphine pattern collection
*/
export function createSeraphinePatterns() {
return {
routing: SERAPHINE_ROUTING_PATTERNS,
complexity: SERAPHINE_COMPLEXITY_PATTERNS,
coverage: SERAPHINE_COVERAGE_PATTERNS,
trajectory: SERAPHINE_TRAJECTORY_PATTERNS,
custom: SERAPHINE_CUSTOM_PATTERNS,
};
}
/**
* Create the Seraphine Genesis CFP document
*/
export function createSeraphineGenesis() {
return createCFP({
name: SERAPHINE_METADATA.name,
description: SERAPHINE_METADATA.description,
patterns: createSeraphinePatterns(),
author: SERAPHINE_METADATA.author,
license: SERAPHINE_METADATA.license,
tags: SERAPHINE_METADATA.tags,
language: SERAPHINE_METADATA.language,
framework: SERAPHINE_METADATA.framework,
});
}
/**
* Get Seraphine model info
*/
export function getSeraphineInfo() {
return {
name: SERAPHINE_METADATA.displayName,
version: SERAPHINE_VERSION,
description: SERAPHINE_METADATA.description,
patternCounts: {
routing: SERAPHINE_ROUTING_PATTERNS.length,
complexity: SERAPHINE_COMPLEXITY_PATTERNS.length,
coverage: SERAPHINE_COVERAGE_PATTERNS.length,
trajectory: SERAPHINE_TRAJECTORY_PATTERNS.length,
custom: SERAPHINE_CUSTOM_PATTERNS.length,
},
};
}
//# sourceMappingURL=seraphine.js.map