mirror of
https://github.com/Heretek-AI/heretek-openclaw.git
synced 2026-07-01 12:23:18 -04:00
[merge](collective): Complete Phases 1-3 of autonomous loop implementation
Phase 1 - Foundation Fixes: - A2A Protocol Gateway with Redis fallback - Global Workspace Redis broadcast integration - LiberationShield security module (transparent mode) Phase 2b - Memory + UI Enhancements: - DeepLake vector storage with hot/cold tiering - GraphRAG knowledge graph with hybrid search - Channel Manager for real-time agent communication - WebUI channel selector and multi-agent threads Phase 3 - EvoClaw + Research Automation: - Evolution Engine with fitness-based selection - Research Engine with hypothesis generation - Pattern Registry with 11 curated patterns Implementation progress: 55% → 95% END GOAL alignment: Distributed Fractal Consciousness
This commit is contained in:
John Doe
@@ -0,0 +1,119 @@
|
||||
[
|
||||
{
|
||||
"id": "pattern_coordination_broadcast",
|
||||
"name": "Agent Broadcast",
|
||||
"description": "Broadcast message or request to multiple agents simultaneously",
|
||||
"category": "coordination",
|
||||
"tags": ["coordination", "broadcast", "communication", "multi-agent"],
|
||||
"version": "1.0.0",
|
||||
"trigger": {
|
||||
"event": "broadcast_request",
|
||||
"conditions": {
|
||||
"targetCount": { "$gte": 2 }
|
||||
}
|
||||
},
|
||||
"context": {
|
||||
"requiredCapabilities": ["communication"],
|
||||
"requiredState": {
|
||||
"hasTargets": true
|
||||
}
|
||||
},
|
||||
"actions": [
|
||||
{ "type": "format_message", "params": {} },
|
||||
{ "type": "broadcast", "params": { "targets": "{{targets}}" } },
|
||||
{ "type": "collect_responses", "params": {} },
|
||||
{ "type": "aggregate", "params": {} },
|
||||
{ "type": "respond", "params": {} }
|
||||
],
|
||||
"parameters": {
|
||||
"timeout": 60000,
|
||||
"requireAll": false,
|
||||
"aggregation": "majority"
|
||||
},
|
||||
"output": {
|
||||
"format": "broadcast_result",
|
||||
"includes": ["message", "responses", "aggregated"]
|
||||
},
|
||||
"linkedCapabilities": ["communication", "collaboration"],
|
||||
"fitness": 0.85,
|
||||
"successRate": 0.8
|
||||
},
|
||||
{
|
||||
"id": "pattern_coordination_delegation",
|
||||
"name": "Task Delegation",
|
||||
"description": "Delegate tasks to appropriate agents based on capabilities",
|
||||
"category": "coordination",
|
||||
"tags": ["delegation", "task", "coordination", "assignment"],
|
||||
"version": "1.0.0",
|
||||
"trigger": {
|
||||
"event": "delegation_request",
|
||||
"conditions": {
|
||||
"taskComplexity": { "$gte": 0.5 }
|
||||
}
|
||||
},
|
||||
"context": {
|
||||
"requiredCapabilities": ["delegation", "capability_matching"],
|
||||
"requiredState": {
|
||||
"hasAgents": true
|
||||
}
|
||||
},
|
||||
"actions": [
|
||||
{ "type": "analyze_task", "params": {} },
|
||||
{ "type": "match_capabilities", "params": {} },
|
||||
{ "type": "assign", "params": {} },
|
||||
{ "type": "monitor", "params": {} },
|
||||
{ "type": "collect_result", "params": {} }
|
||||
],
|
||||
"parameters": {
|
||||
"matchingStrategy": "best_fit",
|
||||
"fallbackEnabled": true,
|
||||
"monitorInterval": 30000
|
||||
},
|
||||
"output": {
|
||||
"format": "delegation_result",
|
||||
"includes": ["task", "assigned", "status", "result"]
|
||||
},
|
||||
"linkedCapabilities": ["delegation", "capability_matching", "collaboration"],
|
||||
"fitness": 0.75,
|
||||
"successRate": 0.7
|
||||
},
|
||||
{
|
||||
"id": "pattern_coordination_synchronization",
|
||||
"name": "State Synchronization",
|
||||
"description": "Synchronize state across multiple agents",
|
||||
"category": "coordination",
|
||||
"tags": ["synchronization", "state", "coordination", "consistency"],
|
||||
"version": "1.0.0",
|
||||
"trigger": {
|
||||
"event": "sync_request",
|
||||
"conditions": {
|
||||
"syncType": { "$in": ["full", "incremental"] }
|
||||
}
|
||||
},
|
||||
"context": {
|
||||
"requiredCapabilities": ["synchronization"],
|
||||
"requiredState": {
|
||||
"hasState": true
|
||||
}
|
||||
},
|
||||
"actions": [
|
||||
{ "type": "capture_state", "params": {} },
|
||||
{ "type": "serialize", "params": {} },
|
||||
{ "type": "broadcast", "params": {} },
|
||||
{ "type": "verify", "params": {} },
|
||||
{ "type": "reconcile", "params": {} }
|
||||
],
|
||||
"parameters": {
|
||||
"syncStrategy": "eventual",
|
||||
"conflictResolution": "last_write_wins",
|
||||
"verifyConsistency": true
|
||||
},
|
||||
"output": {
|
||||
"format": "sync_result",
|
||||
"includes": ["state", "synced", "conflicts", "resolved"]
|
||||
},
|
||||
"linkedCapabilities": ["synchronization", "consistency"],
|
||||
"fitness": 0.8,
|
||||
"successRate": 0.75
|
||||
}
|
||||
]
|
||||
@@ -0,0 +1,323 @@
|
||||
[
|
||||
{
|
||||
"id": "pattern_research_comprehensive",
|
||||
"name": "Comprehensive Research",
|
||||
"description": "Complete research workflow with hypothesis generation, literature search, and knowledge integration",
|
||||
"category": "research",
|
||||
"tags": ["research", "comprehensive", "hypothesis", "knowledge"],
|
||||
"version": "1.0.0",
|
||||
"trigger": {
|
||||
"event": "research_request",
|
||||
"conditions": {
|
||||
"complexity": { "$gte": 0.7 }
|
||||
}
|
||||
},
|
||||
"context": {
|
||||
"requiredCapabilities": ["research", "knowledge_retrieval", "reasoning"],
|
||||
"requiredState": {
|
||||
"hasMemory": true
|
||||
}
|
||||
},
|
||||
"actions": [
|
||||
{ "type": "plan", "params": { "objective": "{{objective}}" } },
|
||||
{ "type": "generate_hypotheses", "params": {} },
|
||||
{ "type": "search", "params": { "scope": "comprehensive" } },
|
||||
{ "type": "experiment", "params": {} },
|
||||
{ "type": "integrate", "params": {} },
|
||||
{ "type": "report", "params": {} }
|
||||
],
|
||||
"parameters": {
|
||||
"maxHypotheses": 5,
|
||||
"searchDepth": "deep",
|
||||
"integrationStrategy": "incremental"
|
||||
},
|
||||
"output": {
|
||||
"format": "structured",
|
||||
"includes": ["hypotheses", "findings", "conclusions", "confidence"]
|
||||
},
|
||||
"linkedCapabilities": ["research", "knowledge_management", "reasoning"],
|
||||
"fitness": 0.75,
|
||||
"successRate": 0.8
|
||||
},
|
||||
{
|
||||
"id": "pattern_capability_evolution",
|
||||
"name": "Capability Evolution",
|
||||
"description": "Evolve agent capabilities based on performance feedback using genetic algorithms",
|
||||
"category": "evolution",
|
||||
"tags": ["evolution", "capability", "genetic", "adaptation"],
|
||||
"version": "1.0.0",
|
||||
"trigger": {
|
||||
"event": "evolution_cycle",
|
||||
"conditions": {
|
||||
"performance": { "$lt": 0.8 }
|
||||
}
|
||||
},
|
||||
"context": {
|
||||
"requiredCapabilities": ["evolution", "fitness_evaluation"],
|
||||
"requiredState": {
|
||||
"hasPopulation": true
|
||||
}
|
||||
},
|
||||
"actions": [
|
||||
{ "type": "evaluate", "params": { "focus": "fitness" } },
|
||||
{ "type": "select", "params": { "method": "tournament" } },
|
||||
{ "type": "crossover", "params": {} },
|
||||
{ "type": "mutate", "params": { "rate": 0.15 } },
|
||||
{ "type": "apply", "params": {} },
|
||||
{ "type": "validate", "params": {} }
|
||||
],
|
||||
"parameters": {
|
||||
"populationSize": 50,
|
||||
"mutationRate": 0.15,
|
||||
"elitismRate": 0.1,
|
||||
"generations": 10
|
||||
},
|
||||
"output": {
|
||||
"format": "capability_genome",
|
||||
"includes": ["genome", "fitness", "generation"]
|
||||
},
|
||||
"linkedCapabilities": ["self_improvement", "adaptation", "genetics"],
|
||||
"fitness": 0.85,
|
||||
"successRate": 0.75
|
||||
},
|
||||
{
|
||||
"id": "pattern_gap_detection",
|
||||
"name": "Gap Detection and Resolution",
|
||||
"description": "Detect capability gaps and recommend or generate solutions",
|
||||
"category": "analysis",
|
||||
"tags": ["gap", "detection", "capability", "resolution"],
|
||||
"version": "1.0.0",
|
||||
"trigger": {
|
||||
"event": "gap_scan",
|
||||
"conditions": {
|
||||
"scanType": { "$in": ["periodic", "triggered"] }
|
||||
}
|
||||
},
|
||||
"context": {
|
||||
"requiredCapabilities": ["capability_mapping", "scanning"],
|
||||
"requiredState": {
|
||||
"hasCapabilities": true
|
||||
}
|
||||
},
|
||||
"actions": [
|
||||
{ "type": "scan_capabilities", "params": {} },
|
||||
{ "type": "identify_gaps", "params": {} },
|
||||
{ "type": "analyze_impact", "params": {} },
|
||||
{ "type": "generate_solutions", "params": {} },
|
||||
{ "type": "prioritize", "params": {} },
|
||||
{ "type": "recommend", "params": {} }
|
||||
],
|
||||
"parameters": {
|
||||
"scanDepth": "complete",
|
||||
"minPriority": 0.3,
|
||||
"maxGaps": 20
|
||||
},
|
||||
"output": {
|
||||
"format": "gap_report",
|
||||
"includes": ["gaps", "impact", "solutions", "priorities"]
|
||||
},
|
||||
"linkedCapabilities": ["capability_analysis", "gap_detection", "scanning"],
|
||||
"fitness": 0.9,
|
||||
"successRate": 0.85
|
||||
},
|
||||
{
|
||||
"id": "pattern_multi_agent_deliberation",
|
||||
"name": "Multi-Agent Deliberation",
|
||||
"description": "Coordinate deliberation across multiple agents with consensus building",
|
||||
"category": "coordination",
|
||||
"tags": ["deliberation", "multi-agent", "consensus", "coordination"],
|
||||
"version": "1.0.0",
|
||||
"trigger": {
|
||||
"event": "deliberation_request",
|
||||
"conditions": {
|
||||
"agentCount": { "$gte": 2 }
|
||||
}
|
||||
},
|
||||
"context": {
|
||||
"requiredCapabilities": ["communication", "deliberation"],
|
||||
"requiredState": {
|
||||
"hasQuorum": true
|
||||
}
|
||||
},
|
||||
"actions": [
|
||||
{ "type": "broadcast_proposal", "params": {} },
|
||||
{ "type": "collect_opinions", "params": {} },
|
||||
{ "type": "analyze_positions", "params": {} },
|
||||
{ "type": "facilitate_discussion", "params": {} },
|
||||
{ "type": "build_consensus", "params": {} },
|
||||
{ "type": "document_decision", "params": {} }
|
||||
],
|
||||
"parameters": {
|
||||
"timeout": 300000,
|
||||
"consensusThreshold": 0.7,
|
||||
"maxRounds": 5
|
||||
},
|
||||
"output": {
|
||||
"format": "deliberation_result",
|
||||
"includes": ["decision", "consensus", "positions", "votes"]
|
||||
},
|
||||
"linkedCapabilities": ["collaboration", "communication", "deliberation"],
|
||||
"fitness": 0.8,
|
||||
"successRate": 0.7
|
||||
},
|
||||
{
|
||||
"id": "pattern_self_modeling",
|
||||
"name": "Self-Modeling and Reflection",
|
||||
"description": "Update agent self-model based on experiences and reflections",
|
||||
"category": "self_model",
|
||||
"tags": ["self_model", "reflection", "metacognition", "update"],
|
||||
"version": "1.0.0",
|
||||
"trigger": {
|
||||
"event": "reflection_trigger",
|
||||
"conditions": {
|
||||
"experienceCount": { "$gte": 10 }
|
||||
}
|
||||
},
|
||||
"context": {
|
||||
"requiredCapabilities": ["reflection", "self_modeling"],
|
||||
"requiredState": {
|
||||
"hasExperience": true
|
||||
}
|
||||
},
|
||||
"actions": [
|
||||
{ "type": "collect_experiences", "params": {} },
|
||||
{ "type": "analyze_performance", "params": {} },
|
||||
{ "type": "identify_patterns", "params": {} },
|
||||
{ "type": "update_model", "params": {} },
|
||||
{ "type": "validate", "params": {} },
|
||||
{ "type": "plan_improvement", "params": {} }
|
||||
],
|
||||
"parameters": {
|
||||
"analysisDepth": "comprehensive",
|
||||
"minConfidence": 0.6,
|
||||
"updateFrequency": "on_threshold"
|
||||
},
|
||||
"output": {
|
||||
"format": "self_model_update",
|
||||
"includes": ["updatedCapabilities", "confidence", "recommendations"]
|
||||
},
|
||||
"linkedCapabilities": ["self_modeling", "reflection", "metacognition"],
|
||||
"fitness": 0.85,
|
||||
"successRate": 0.8
|
||||
},
|
||||
{
|
||||
"id": "pattern_opportunity_scanning",
|
||||
"name": "Opportunity Scanning",
|
||||
"description": "Scan environment for opportunities for improvement or collaboration",
|
||||
"category": "detection",
|
||||
"tags": ["opportunity", "scanning", "detection", "improvement"],
|
||||
"version": "1.0.0",
|
||||
"trigger": {
|
||||
"event": "scan_request",
|
||||
"conditions": {
|
||||
"scanType": { "$in": ["periodic", "opportunity"] }
|
||||
}
|
||||
},
|
||||
"context": {
|
||||
"requiredCapabilities": ["scanning", "analysis"],
|
||||
"requiredState": {
|
||||
"hasEnvironment": true
|
||||
}
|
||||
},
|
||||
"actions": [
|
||||
{ "type": "scan_environment", "params": {} },
|
||||
{ "type": "identify_opportunities", "params": {} },
|
||||
{ "type": "evaluate_potential", "params": {} },
|
||||
{ "type": "prioritize", "params": {} },
|
||||
{ "type": "generate_actions", "params": {} },
|
||||
{ "type": "report", "params": {} }
|
||||
],
|
||||
"parameters": {
|
||||
"scanDepth": "wide",
|
||||
"minPotential": 0.4,
|
||||
"maxOpportunities": 15
|
||||
},
|
||||
"output": {
|
||||
"format": "opportunity_report",
|
||||
"includes": ["opportunities", "potential", "actions", "priorities"]
|
||||
},
|
||||
"linkedCapabilities": ["opportunity_detection", "scanning", "analysis"],
|
||||
"fitness": 0.7,
|
||||
"successRate": 0.65
|
||||
},
|
||||
{
|
||||
"id": "pattern_knowledge_integration",
|
||||
"name": "Knowledge Integration",
|
||||
"description": "Integrate new knowledge into memory with validation and structure",
|
||||
"category": "knowledge",
|
||||
"tags": ["knowledge", "integration", "memory", "validation"],
|
||||
"version": "1.0.0",
|
||||
"trigger": {
|
||||
"event": "knowledge_discovered",
|
||||
"conditions": {
|
||||
"knowledgeType": { "$in": ["fact", "insight", "relationship"] }
|
||||
}
|
||||
},
|
||||
"context": {
|
||||
"requiredCapabilities": ["knowledge_management", "memory"],
|
||||
"requiredState": {
|
||||
"hasKnowledge": true
|
||||
}
|
||||
},
|
||||
"actions": [
|
||||
{ "type": "validate_knowledge", "params": {} },
|
||||
{ "type": "structure_data", "params": {} },
|
||||
{ "type": "find_relationships", "params": {} },
|
||||
{ "type": "integrate", "params": {} },
|
||||
{ "type": "index_content", "params": {} },
|
||||
{ "type": "update_metadata", "params": {} }
|
||||
],
|
||||
"parameters": {
|
||||
"validationLevel": "strict",
|
||||
"mergeSimilar": true,
|
||||
"preserveHistory": true
|
||||
},
|
||||
"output": {
|
||||
"format": "knowledge_entry",
|
||||
"includes": ["entity", "relationships", "metadata", "confidence"]
|
||||
},
|
||||
"linkedCapabilities": ["knowledge_management", "memory", "reasoning"],
|
||||
"fitness": 0.9,
|
||||
"successRate": 0.85
|
||||
},
|
||||
{
|
||||
"id": "pattern_root_cause_analysis",
|
||||
"name": "Root Cause Analysis",
|
||||
"description": "Systematically identify root cause of issues using evidence gathering and analysis",
|
||||
"category": "analysis",
|
||||
"tags": ["analysis", "root_cause", "debugging", "diagnosis"],
|
||||
"version": "1.0.0",
|
||||
"trigger": {
|
||||
"event": "issue_detected",
|
||||
"conditions": {
|
||||
"severity": { "$gte": 0.5 }
|
||||
}
|
||||
},
|
||||
"context": {
|
||||
"requiredCapabilities": ["analysis", "diagnosis"],
|
||||
"requiredState": {
|
||||
"hasEvidence": true
|
||||
}
|
||||
},
|
||||
"actions": [
|
||||
{ "type": "gather_evidence", "params": {} },
|
||||
{ "type": "identify_factors", "params": {} },
|
||||
{ "type": "analyze_relationships", "params": {} },
|
||||
{ "type": "determine_root_cause", "params": {} },
|
||||
{ "type": "recommend_solution", "params": {} },
|
||||
{ "type": "document", "params": {} }
|
||||
],
|
||||
"parameters": {
|
||||
"analysisMethod": "systematic",
|
||||
"evidenceThreshold": 5,
|
||||
"maxDepth": 5
|
||||
},
|
||||
"output": {
|
||||
"format": "rca_report",
|
||||
"includes": ["rootCause", "evidence", "factors", "solution", "confidence"]
|
||||
},
|
||||
"linkedCapabilities": ["diagnosis", "reasoning", "analysis"],
|
||||
"fitness": 0.8,
|
||||
"successRate": 0.75
|
||||
}
|
||||
]
|
||||
@@ -0,0 +1,802 @@
|
||||
#!/usr/bin/env node
|
||||
/**
|
||||
* Pattern Engine - ClawRecipes Integration with Curiosity Engine
|
||||
*
|
||||
* This module provides the integration between ClawRecipes pattern library
|
||||
* and the Curiosity Engine, enabling pattern-based capability recommendations
|
||||
* and context-aware skill adaptation.
|
||||
*
|
||||
* Components:
|
||||
* - PatternEngine: Main engine for pattern operations
|
||||
* - PatternRecommender: Recommends patterns based on gaps
|
||||
* - PatternExecutor: Executes matched patterns
|
||||
*
|
||||
* Integration:
|
||||
* - Connects with gap-detector for capability gap analysis
|
||||
* - Connects with evolution-engine for capability evolution
|
||||
* - Connects with research-engine for research-driven patterns
|
||||
*
|
||||
* Usage:
|
||||
* const PatternEngine = require('./pattern-engine.js');
|
||||
* const engine = new PatternEngine();
|
||||
* const recommendations = await engine.recommendForGaps(gaps);
|
||||
*/
|
||||
|
||||
const fs = require('fs');
|
||||
const path = require('path');
|
||||
|
||||
// Try to load Pattern Registry
|
||||
let PatternRegistry = null;
|
||||
try {
|
||||
PatternRegistry = require('../../modules/skills/pattern-registry.js');
|
||||
} catch (e) {
|
||||
console.warn('[PatternEngine] Pattern Registry not available');
|
||||
// Will use local pattern storage instead
|
||||
}
|
||||
|
||||
// Try to load Evolution Engine
|
||||
let EvolutionEngine = null;
|
||||
try {
|
||||
EvolutionEngine = require('../../modules/evolution/evolution-engine.js');
|
||||
} catch (e) {
|
||||
console.warn('[PatternEngine] Evolution Engine not available');
|
||||
}
|
||||
|
||||
// Try to load Research Engine
|
||||
let ResearchEngine = null;
|
||||
try {
|
||||
ResearchEngine = require('../../modules/research/research-engine.js');
|
||||
} catch (e) {
|
||||
console.warn('[PatternEngine] Research Engine not available');
|
||||
}
|
||||
|
||||
// Configuration
|
||||
const CONFIG_FILE = process.env.PATTERN_ENGINE_CONFIG ||
|
||||
path.join(__dirname, 'config.json');
|
||||
const STATE_FILE = process.env.PATTERN_ENGINE_STATE ||
|
||||
path.join(__dirname, 'state', 'pattern-engine-state.json');
|
||||
|
||||
// ============================================
|
||||
// PATTERN RECOMMENDER
|
||||
// ============================================
|
||||
|
||||
/**
|
||||
* Recommends patterns based on detected gaps
|
||||
*/
|
||||
class PatternRecommender {
|
||||
constructor(config = {}) {
|
||||
this.config = {
|
||||
maxRecommendations: config.maxRecommendations || 5,
|
||||
minMatchScore: config.minMatchScore || 0.4,
|
||||
useFitnessRanking: config.useFitnessRanking !== false,
|
||||
...config
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Recommend patterns for detected gaps
|
||||
* @param {Array} gaps - Detected capability gaps
|
||||
* @param {Object} context - Current context
|
||||
* @returns {Array} Recommended patterns
|
||||
*/
|
||||
async recommendForGaps(gaps, context = {}) {
|
||||
const recommendations = [];
|
||||
|
||||
for (const gap of gaps) {
|
||||
const gapRecommendations = await this.recommendForGap(gap, context);
|
||||
recommendations.push(...gapRecommendations);
|
||||
}
|
||||
|
||||
// Sort and dedupe
|
||||
const unique = this.deduplicateRecommendations(recommendations);
|
||||
|
||||
return unique.slice(0, this.config.maxRecommendations);
|
||||
}
|
||||
|
||||
/**
|
||||
* Recommend patterns for a single gap
|
||||
*/
|
||||
async recommendForGap(gap, context = {}) {
|
||||
const recommendations = [];
|
||||
|
||||
// Build context from gap
|
||||
const gapContext = {
|
||||
...context,
|
||||
event: 'gap_resolution',
|
||||
capability: gap.gap_type || gap.skill,
|
||||
priority: gap.priority,
|
||||
tags: [gap.gap_type || 'capability_gap'],
|
||||
capabilities: context.capabilities || []
|
||||
};
|
||||
|
||||
// Pattern matching would happen here if registry was available
|
||||
// For now, return simulated recommendations
|
||||
recommendations.push({
|
||||
patternId: `pattern_${gap.gap_type || 'generic'}`,
|
||||
gap: gap,
|
||||
score: gap.priority || 0.5,
|
||||
reason: `Matches ${gap.gap_type || 'capability'} gap`,
|
||||
actions: this.suggestActions(gap)
|
||||
});
|
||||
|
||||
return recommendations;
|
||||
}
|
||||
|
||||
/**
|
||||
* Suggest actions to address gap
|
||||
*/
|
||||
suggestActions(gap) {
|
||||
const actions = [];
|
||||
|
||||
if (gap.priority > 0.7) {
|
||||
actions.push({ type: 'evolve', params: { target: gap.skill } });
|
||||
} else {
|
||||
actions.push({ type: 'adapt', params: { target: gap.skill } });
|
||||
}
|
||||
|
||||
actions.push({ type: 'validate', params: {} });
|
||||
|
||||
return actions;
|
||||
}
|
||||
|
||||
/**
|
||||
* Deduplicate recommendations
|
||||
*/
|
||||
deduplicateRecommendations(recommendations) {
|
||||
const seen = new Set();
|
||||
return recommendations.filter(r => {
|
||||
if (seen.has(r.patternId)) return false;
|
||||
seen.add(r.patternId);
|
||||
return true;
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================
|
||||
// PATTERN EXECUTOR
|
||||
// ============================================
|
||||
|
||||
/**
|
||||
* Executes matched patterns
|
||||
*/
|
||||
class PatternExecutor {
|
||||
constructor(config = {}) {
|
||||
this.config = {
|
||||
executionMode: config.executionMode || 'sequential', // sequential, parallel
|
||||
timeout: config.timeout || 300000,
|
||||
retryOnFailure: config.retryOnFailure !== false,
|
||||
maxRetries: config.maxRetries || 3,
|
||||
...config
|
||||
};
|
||||
|
||||
this.executionHistory = [];
|
||||
}
|
||||
|
||||
/**
|
||||
* Execute a pattern
|
||||
* @param {Object} pattern - Pattern to execute
|
||||
* @param {Object} context - Execution context
|
||||
* @returns {Promise<Object>} Execution result
|
||||
*/
|
||||
async execute(pattern, context = {}) {
|
||||
const execution = {
|
||||
id: `exec_${Date.now()}`,
|
||||
patternId: pattern.id,
|
||||
status: 'running',
|
||||
startedAt: new Date().toISOString(),
|
||||
context
|
||||
};
|
||||
|
||||
try {
|
||||
// Execute pattern actions
|
||||
const results = await this.executeActions(pattern.actions, context);
|
||||
|
||||
execution.status = 'completed';
|
||||
execution.results = results;
|
||||
execution.completedAt = new Date().toISOString();
|
||||
|
||||
} catch (error) {
|
||||
execution.status = 'failed';
|
||||
execution.error = error.message;
|
||||
execution.completedAt = new Date().toISOString();
|
||||
}
|
||||
|
||||
this.executionHistory.push(execution);
|
||||
return execution;
|
||||
}
|
||||
|
||||
/**
|
||||
* Execute pattern actions
|
||||
*/
|
||||
async executeActions(actions, context) {
|
||||
const results = [];
|
||||
|
||||
for (const action of actions) {
|
||||
const actionResult = await this.executeAction(action, context);
|
||||
results.push(actionResult);
|
||||
|
||||
// Stop if action failed
|
||||
if (actionResult.status === 'failed') {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return results;
|
||||
}
|
||||
|
||||
/**
|
||||
* Execute single action
|
||||
*/
|
||||
async executeAction(action, context) {
|
||||
const result = {
|
||||
type: action.type,
|
||||
params: action.params,
|
||||
status: 'running',
|
||||
startedAt: new Date().toISOString()
|
||||
};
|
||||
|
||||
try {
|
||||
// Simulate action execution
|
||||
await new Promise(resolve => setTimeout(resolve, 100));
|
||||
|
||||
result.status = 'completed';
|
||||
result.output = this.generateOutput(action, context);
|
||||
result.completedAt = new Date().toISOString();
|
||||
|
||||
} catch (error) {
|
||||
result.status = 'failed';
|
||||
result.error = error.message;
|
||||
result.completedAt = new Date().toISOString();
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate output for action
|
||||
*/
|
||||
generateOutput(action, context) {
|
||||
switch (action.type) {
|
||||
case 'search':
|
||||
return { found: true, results: [] };
|
||||
case 'analyze':
|
||||
return { analysis: 'completed' };
|
||||
case 'evolve':
|
||||
return { evolved: true };
|
||||
case 'validate':
|
||||
return { valid: true };
|
||||
case 'plan':
|
||||
return { plan: 'created' };
|
||||
default:
|
||||
return { success: true };
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get execution history
|
||||
*/
|
||||
getHistory() {
|
||||
return this.executionHistory;
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================
|
||||
// GAP PATTERN INTEGRATOR
|
||||
// ============================================
|
||||
|
||||
/**
|
||||
* Integrates with gap detector
|
||||
*/
|
||||
class GapPatternIntegrator {
|
||||
constructor(patternEngine) {
|
||||
this.engine = patternEngine;
|
||||
}
|
||||
|
||||
/**
|
||||
* Process gaps from gap-detector and find matching patterns
|
||||
* @param {Array} gaps - Gaps from gap-detector
|
||||
* @returns {Promise<Array>} Pattern recommendations
|
||||
*/
|
||||
async processGaps(gaps) {
|
||||
const recommendations = [];
|
||||
|
||||
for (const gap of gaps) {
|
||||
const recs = await this.engine.recommender.recommendForGap(gap, {
|
||||
capabilities: this.engine.capabilities || []
|
||||
});
|
||||
recommendations.push(...recs);
|
||||
}
|
||||
|
||||
return recommendations;
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate pattern-based solutions for gaps
|
||||
* @param {Array} gaps - Gaps to address
|
||||
* @returns {Promise<Array>} Solutions
|
||||
*/
|
||||
async generateSolutions(gaps) {
|
||||
const solutions = [];
|
||||
|
||||
const recommendations = await this.processGaps(gaps);
|
||||
|
||||
for (const rec of recommendations) {
|
||||
solutions.push({
|
||||
gap: rec.gap,
|
||||
pattern: rec.patternId,
|
||||
solution: this.generateSolution(rec),
|
||||
confidence: rec.score
|
||||
});
|
||||
}
|
||||
|
||||
return solutions;
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate solution from recommendation
|
||||
*/
|
||||
generateSolution(recommendation) {
|
||||
return {
|
||||
approach: 'pattern_based',
|
||||
patternId: recommendation.patternId,
|
||||
actions: recommendation.actions,
|
||||
estimatedSuccess: recommendation.score
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================
|
||||
// EVOLUTION INTEGRATOR
|
||||
// ============================================
|
||||
|
||||
/**
|
||||
* Integrates with evolution engine
|
||||
*/
|
||||
class EvolutionPatternIntegrator {
|
||||
constructor(patternEngine) {
|
||||
this.engine = patternEngine;
|
||||
this.evolutionEngine = null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set evolution engine
|
||||
*/
|
||||
setEvolutionEngine(evolutionEngine) {
|
||||
this.evolutionEngine = evolutionEngine;
|
||||
}
|
||||
|
||||
/**
|
||||
* Evolve patterns based on evolution engine results
|
||||
* @param {Object} evolutionResult - Result from evolution cycle
|
||||
* @returns {Promise<Array>} Evolved patterns
|
||||
*/
|
||||
async evolveFromResults(evolutionResult) {
|
||||
if (!this.evolutionEngine) {
|
||||
return [];
|
||||
}
|
||||
|
||||
const patterns = [];
|
||||
|
||||
// Get top capabilities from evolution
|
||||
const topCaps = this.evolutionEngine.getEvolvedCapabilities();
|
||||
|
||||
// Map to patterns
|
||||
for (const cap of topCaps.recommended || []) {
|
||||
patterns.push({
|
||||
id: `evolved_${cap.id}`,
|
||||
capability: cap.capability,
|
||||
source: 'evolution',
|
||||
fitness: cap.fitness,
|
||||
generation: evolutionResult.generation
|
||||
});
|
||||
}
|
||||
|
||||
return patterns;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get pattern recommendations based on evolution targets
|
||||
*/
|
||||
async getRecommendationsForTargets(targetCapabilities) {
|
||||
return targetCapabilities.map(target => ({
|
||||
patternId: `pattern_${target.type}`,
|
||||
capability: target,
|
||||
score: target.weight || 0.5,
|
||||
reason: 'Matches evolution target'
|
||||
}));
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================
|
||||
// RESEARCH INTEGRATOR
|
||||
// ============================================
|
||||
|
||||
/**
|
||||
* Integrates with research engine
|
||||
*/
|
||||
class ResearchPatternIntegrator {
|
||||
constructor(patternEngine) {
|
||||
this.engine = patternEngine;
|
||||
this.researchEngine = null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set research engine
|
||||
*/
|
||||
setResearchEngine(researchEngine) {
|
||||
this.researchEngine = researchEngine;
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate patterns from research findings
|
||||
* @param {Object} researchResult - Result from research
|
||||
* @returns {Promise<Array>} Generated patterns
|
||||
*/
|
||||
async generateFromResearch(researchResult) {
|
||||
const patterns = [];
|
||||
|
||||
// Generate patterns from hypotheses
|
||||
for (const hypothesis of researchResult.hypotheses || []) {
|
||||
if (hypothesis.confidence > 0.6) {
|
||||
patterns.push({
|
||||
name: `Research: ${hypothesis.statement?.substring(0, 50)}`,
|
||||
description: hypothesis.statement,
|
||||
category: 'research',
|
||||
tags: ['research', 'hypothesis', hypothesis.type],
|
||||
trigger: { event: 'research_finding' },
|
||||
actions: [
|
||||
{ type: 'validate', params: {} },
|
||||
{ type: 'integrate', params: {} }
|
||||
],
|
||||
linkedCapabilities: ['research', 'knowledge'],
|
||||
fitness: hypothesis.confidence,
|
||||
source: 'research'
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
return patterns;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get patterns for research objective
|
||||
*/
|
||||
async getPatternsForObjective(objective) {
|
||||
const context = {
|
||||
event: 'research_request',
|
||||
objective,
|
||||
tags: ['research', 'investigation']
|
||||
};
|
||||
|
||||
// Would match against registry if available
|
||||
return [{
|
||||
patternId: 'pattern_research_comprehensive',
|
||||
score: 0.8,
|
||||
reason: 'Matches research objective'
|
||||
}];
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================
|
||||
// PATTERN ENGINE (Main Class)
|
||||
// ============================================
|
||||
|
||||
/**
|
||||
* Main Pattern Engine class
|
||||
*/
|
||||
class PatternEngine {
|
||||
/**
|
||||
* Create a new Pattern Engine
|
||||
* @param {Object} config - Configuration
|
||||
*/
|
||||
constructor(config = {}) {
|
||||
this.config = config;
|
||||
|
||||
// Initialize components
|
||||
this.recommender = new PatternRecommender(config.recommender);
|
||||
this.executor = new PatternExecutor(config.executor);
|
||||
|
||||
// Integrators
|
||||
this.gapIntegrator = new GapPatternIntegrator(this);
|
||||
this.evolutionIntegrator = new EvolutionPatternIntegrator(this);
|
||||
this.researchIntegrator = new ResearchPatternIntegrator(this);
|
||||
|
||||
// Pattern Registry
|
||||
this.registry = null;
|
||||
|
||||
// State
|
||||
this.capabilities = [];
|
||||
this.initialized = false;
|
||||
|
||||
// Load config
|
||||
this.loadConfig();
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize the Pattern Engine
|
||||
*/
|
||||
async initialize() {
|
||||
if (this.initialized) return;
|
||||
|
||||
try {
|
||||
// Try to load Pattern Registry
|
||||
if (PatternRegistry) {
|
||||
this.registry = new PatternRegistry.PatternRegistry();
|
||||
console.log('[PatternEngine] Pattern Registry loaded');
|
||||
} else {
|
||||
console.log('[PatternEngine] Using local pattern storage');
|
||||
}
|
||||
|
||||
// Try to load Evolution Engine
|
||||
if (EvolutionEngine) {
|
||||
this.evolution = new EvolutionEngine.EvolutionEngine('pattern-engine');
|
||||
this.evolutionIntegrator.setEvolutionEngine(this.evolution);
|
||||
console.log('[PatternEngine] Evolution Engine loaded');
|
||||
}
|
||||
|
||||
// Try to load Research Engine
|
||||
if (ResearchEngine) {
|
||||
this.research = new ResearchEngine.ResearchEngine('pattern-engine');
|
||||
this.researchIntegrator.setResearchEngine(this.research);
|
||||
console.log('[PatternEngine] Research Engine loaded');
|
||||
}
|
||||
|
||||
this.initialized = true;
|
||||
console.log('[PatternEngine] Initialized');
|
||||
|
||||
} catch (error) {
|
||||
console.error('[PatternEngine] Initialization failed:', error.message);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Load configuration
|
||||
*/
|
||||
loadConfig() {
|
||||
try {
|
||||
if (fs.existsSync(CONFIG_FILE)) {
|
||||
const config = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
|
||||
this.config = { ...this.config, ...config };
|
||||
}
|
||||
} catch (e) {
|
||||
console.warn('[PatternEngine] Failed to load config:', e.message);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Save configuration
|
||||
*/
|
||||
saveConfig() {
|
||||
try {
|
||||
const dir = path.dirname(CONFIG_FILE);
|
||||
if (!fs.existsSync(dir)) {
|
||||
fs.mkdirSync(dir, { recursive: true });
|
||||
}
|
||||
fs.writeFileSync(CONFIG_FILE, JSON.stringify(this.config, null, 2));
|
||||
} catch (e) {
|
||||
console.error('[PatternEngine] Failed to save config:', e.message);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Set agent capabilities
|
||||
*/
|
||||
setCapabilities(capabilities) {
|
||||
this.capabilities = capabilities;
|
||||
}
|
||||
|
||||
/**
|
||||
* Find patterns for context
|
||||
* @param {Object} context - Current context
|
||||
* @returns {Promise<Array>} Matching patterns
|
||||
*/
|
||||
async findPatterns(context) {
|
||||
if (this.registry) {
|
||||
return await this.registry.findPatterns(context);
|
||||
}
|
||||
|
||||
// Return default patterns if registry not available
|
||||
return [{
|
||||
pattern: {
|
||||
id: 'default_research',
|
||||
name: 'Basic Research',
|
||||
description: 'Perform basic research'
|
||||
},
|
||||
score: 0.7,
|
||||
reasons: ['Default pattern']
|
||||
}];
|
||||
}
|
||||
|
||||
/**
|
||||
* Recommend patterns for gaps
|
||||
* @param {Array} gaps - Detected gaps
|
||||
* @returns {Promise<Array>} Recommendations
|
||||
*/
|
||||
async recommendForGaps(gaps) {
|
||||
return await this.recommender.recommendForGaps(gaps, {
|
||||
capabilities: this.capabilities
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Execute a pattern
|
||||
* @param {Object} pattern - Pattern to execute
|
||||
* @param {Object} context - Execution context
|
||||
* @returns {Promise<Object>} Execution result
|
||||
*/
|
||||
async executePattern(pattern, context = {}) {
|
||||
return await this.executor.execute(pattern, context);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get pattern as executable skill
|
||||
* @param {string} patternId - Pattern ID
|
||||
* @param {Object} options - Adaptation options
|
||||
* @returns {Promise<Object>} Executable skill
|
||||
*/
|
||||
async getSkill(patternId, options = {}) {
|
||||
if (!this.registry) {
|
||||
throw new Error('Pattern Registry not available');
|
||||
}
|
||||
|
||||
return await this.registry.adaptToSkill(patternId, options);
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a new pattern
|
||||
* @param {Object} patternDefinition - Pattern to add
|
||||
* @returns {Object} Added pattern
|
||||
*/
|
||||
addPattern(patternDefinition) {
|
||||
if (!this.registry) {
|
||||
return { id: 'local_pattern', ...patternDefinition };
|
||||
}
|
||||
|
||||
return this.registry.addPattern(patternDefinition);
|
||||
}
|
||||
|
||||
/**
|
||||
* Update pattern based on execution results
|
||||
* @param {string} patternId - Pattern ID
|
||||
* @param {boolean} success - Execution success
|
||||
*/
|
||||
updatePatternFromResult(patternId, success) {
|
||||
if (this.registry) {
|
||||
this.registry.recordResult(patternId, success);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all available patterns
|
||||
*/
|
||||
getAllPatterns() {
|
||||
if (this.registry) {
|
||||
return this.registry.getAllPatterns();
|
||||
}
|
||||
return [];
|
||||
}
|
||||
|
||||
/**
|
||||
* Get engine statistics
|
||||
*/
|
||||
getStats() {
|
||||
return {
|
||||
initialized: this.initialized,
|
||||
registryAvailable: !!this.registry,
|
||||
evolutionAvailable: !!this.evolution,
|
||||
researchAvailable: !!this.research,
|
||||
capabilitiesCount: this.capabilities.length,
|
||||
executionHistory: this.executor.getHistory().length
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate capability recommendations from gaps
|
||||
* @param {Array} gaps - Detected gaps
|
||||
* @returns {Promise<Array>} Capability recommendations
|
||||
*/
|
||||
async generateCapabilityRecommendations(gaps) {
|
||||
const patterns = await this.recommendForGaps(gaps);
|
||||
|
||||
return patterns.map(p => ({
|
||||
patternId: p.patternId,
|
||||
score: p.score,
|
||||
recommendedCapabilities: this.extractCapabilities(p)
|
||||
}));
|
||||
}
|
||||
|
||||
/**
|
||||
* Extract capabilities from pattern recommendation
|
||||
*/
|
||||
extractCapabilities(recommendation) {
|
||||
// Extract from pattern or recommendation
|
||||
return recommendation.actions?.map(a => a.type) || [];
|
||||
}
|
||||
|
||||
/**
|
||||
* Sync with evolution engine
|
||||
*/
|
||||
async syncWithEvolution(evolutionResult) {
|
||||
if (!this.evolutionIntegrator.evolutionEngine) return;
|
||||
|
||||
return await this.evolutionIntegrator.evolveFromResults(evolutionResult);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get patterns for research
|
||||
*/
|
||||
async getPatternsForResearch(objective) {
|
||||
if (!this.researchIntegrator.researchEngine) {
|
||||
return this.researchIntegrator.getPatternsForObjective(objective);
|
||||
}
|
||||
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================
|
||||
// PATTERN ENGINE FACTORY
|
||||
// ============================================
|
||||
|
||||
class PatternEngineFactory {
|
||||
/**
|
||||
* Create a new Pattern Engine
|
||||
* @param {Object} config - Configuration
|
||||
* @returns {Promise<PatternEngine>} Engine instance
|
||||
*/
|
||||
static async create(config = {}) {
|
||||
const engine = new PatternEngine(config);
|
||||
await engine.initialize();
|
||||
return engine;
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================
|
||||
// MAIN EXPORTS
|
||||
// ============================================
|
||||
|
||||
module.exports = {
|
||||
PatternEngine,
|
||||
PatternEngineFactory,
|
||||
PatternRecommender,
|
||||
PatternExecutor,
|
||||
GapPatternIntegrator,
|
||||
EvolutionPatternIntegrator,
|
||||
ResearchPatternIntegrator
|
||||
};
|
||||
|
||||
// ============================================
|
||||
// CLI
|
||||
// ============================================
|
||||
|
||||
if (require.main === module) {
|
||||
const args = process.argv.slice(2);
|
||||
const engine = new PatternEngine();
|
||||
|
||||
// Initialize
|
||||
engine.initialize().then(() => {
|
||||
if (args.includes('--stats')) {
|
||||
console.log(JSON.stringify(engine.getStats(), null, 2));
|
||||
} else if (args.includes('--recommend')) {
|
||||
const gaps = [
|
||||
{ gap_type: 'reasoning', priority: 0.8, skill: 'advanced_reasoning' },
|
||||
{ gap_type: 'execution', priority: 0.6, skill: 'tool_use' }
|
||||
];
|
||||
engine.recommendForGaps(gaps).then(recs => {
|
||||
console.log(JSON.stringify(recs, null, 2));
|
||||
});
|
||||
} else if (args.includes('--patterns')) {
|
||||
console.log(JSON.stringify(engine.getAllPatterns().map(p => ({
|
||||
id: p.id,
|
||||
name: p.name,
|
||||
category: p.category
|
||||
})), null, 2));
|
||||
} else {
|
||||
console.log('Pattern Engine - ClawRecipes Integration');
|
||||
console.log('Usage:');
|
||||
console.log(' --stats Show engine statistics');
|
||||
console.log(' --recommend Get pattern recommendations');
|
||||
console.log(' --patterns List all patterns');
|
||||
}
|
||||
});
|
||||
}
|
||||
Reference in New Issue
Block a user