Skip to content

armgit / ruflo

Public Imported from GitHub
0

🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated

Checkpoint: File edits

rUv406e11b31123
diff --git a/v3/@claude-flow/cli/src/transfer/models/seraphine.ts b/v3/@claude-flow/cli/src/transfer/models/seraphine.ts
new file mode 100644
index 0000000000..bf171813b5
--- /dev/null
+++ b/v3/@claude-flow/cli/src/transfer/models/seraphine.ts
@@ -0,0 +1,397 @@
+/**
+ * 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 type {
+ CFPFormat,
+ PatternCollection,
+ RoutingPattern,
+ ComplexityPattern,
+ CoveragePattern,
+ TrajectoryPattern,
+ CustomPattern,
+} from '../types.js';
+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: RoutingPattern[] = [
+ {
+ 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: ComplexityPattern[] = [
+ {
+ 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: CoveragePattern[] = [
+ {
+ 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: TrajectoryPattern[] = [
+ {
+ 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: CustomPattern[] = [
+ {
+ 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(): PatternCollection {
+ 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(): CFPFormat {
+ 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(): {
+ name: string;
+ version: string;
+ description: string;
+ patternCounts: Record<string, number>;
+} {
+ 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,
+ },
+ };
+}