Complete BZZZ functionality port to CHORUS
🎭 CHORUS now contains full BZZZ functionality adapted for containers Core systems ported: - P2P networking (libp2p with DHT and PubSub) - Task coordination (COOEE protocol) - HMMM collaborative reasoning - SHHH encryption and security - SLURP admin election system - UCXL content addressing - UCXI server integration - Hypercore logging system - Health monitoring and graceful shutdown - License validation with KACHING Container adaptations: - Environment variable configuration (no YAML files) - Container-optimized logging to stdout/stderr - Auto-generated agent IDs for container deployments - Docker-first architecture All proven BZZZ P2P protocols, AI integration, and collaboration features are now available in containerized form. Next: Build and test container deployment. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
anthonyrawlins
776
pkg/integration/slurp_events.go
Normal file
776
pkg/integration/slurp_events.go
Normal file
@@ -0,0 +1,776 @@
|
||||
package integration
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"math"
|
||||
"regexp"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"chorus.services/bzzz/pkg/config"
|
||||
"chorus.services/bzzz/pkg/ucxl"
|
||||
"chorus.services/bzzz/pubsub"
|
||||
"github.com/libp2p/go-libp2p/core/peer"
|
||||
)
|
||||
|
||||
// SlurpEventIntegrator manages the integration between HMMM discussions and SLURP events
|
||||
type SlurpEventIntegrator struct {
|
||||
config config.SlurpConfig
|
||||
client *SlurpClient
|
||||
pubsub *pubsub.PubSub
|
||||
eventMapping config.HmmmToSlurpMapping
|
||||
decisionPublisher *DecisionPublisher
|
||||
|
||||
// Batch processing
|
||||
eventBatch []SlurpEvent
|
||||
batchMutex sync.Mutex
|
||||
batchTimer *time.Timer
|
||||
|
||||
// Context and lifecycle
|
||||
ctx context.Context
|
||||
cancel context.CancelFunc
|
||||
|
||||
// Statistics
|
||||
stats SlurpIntegrationStats
|
||||
statsMutex sync.RWMutex
|
||||
}
|
||||
|
||||
// SlurpIntegrationStats tracks integration performance metrics
|
||||
type SlurpIntegrationStats struct {
|
||||
EventsGenerated int64 `json:"events_generated"`
|
||||
EventsSuccessful int64 `json:"events_successful"`
|
||||
EventsFailed int64 `json:"events_failed"`
|
||||
BatchesSent int64 `json:"batches_sent"`
|
||||
LastEventTime time.Time `json:"last_event_time"`
|
||||
LastSuccessTime time.Time `json:"last_success_time"`
|
||||
LastFailureTime time.Time `json:"last_failure_time"`
|
||||
LastFailureError string `json:"last_failure_error"`
|
||||
AverageResponseTime float64 `json:"average_response_time_ms"`
|
||||
}
|
||||
|
||||
// HmmmDiscussionContext represents a HMMM discussion that can generate SLURP events
|
||||
type HmmmDiscussionContext struct {
|
||||
DiscussionID string `json:"discussion_id"`
|
||||
SessionID string `json:"session_id,omitempty"`
|
||||
Participants []string `json:"participants"`
|
||||
StartTime time.Time `json:"start_time"`
|
||||
EndTime time.Time `json:"end_time"`
|
||||
Messages []HmmmMessage `json:"messages"`
|
||||
ConsensusReached bool `json:"consensus_reached"`
|
||||
ConsensusStrength float64 `json:"consensus_strength"`
|
||||
OutcomeType string `json:"outcome_type"`
|
||||
ProjectPath string `json:"project_path"`
|
||||
RelatedTasks []string `json:"related_tasks,omitempty"`
|
||||
Metadata map[string]interface{} `json:"metadata,omitempty"`
|
||||
}
|
||||
|
||||
// HmmmMessage represents a message in a HMMM discussion
|
||||
type HmmmMessage struct {
|
||||
From string `json:"from"`
|
||||
Content string `json:"content"`
|
||||
Type string `json:"type"`
|
||||
Timestamp time.Time `json:"timestamp"`
|
||||
Metadata map[string]interface{} `json:"metadata,omitempty"`
|
||||
}
|
||||
|
||||
// NewSlurpEventIntegrator creates a new SLURP event integrator
|
||||
func NewSlurpEventIntegrator(ctx context.Context, slurpConfig config.SlurpConfig, ps *pubsub.PubSub, decisionPublisher *DecisionPublisher) (*SlurpEventIntegrator, error) {
|
||||
if !slurpConfig.Enabled {
|
||||
return nil, fmt.Errorf("SLURP integration is disabled in configuration")
|
||||
}
|
||||
|
||||
client := NewSlurpClient(slurpConfig)
|
||||
|
||||
// Test connection to SLURP
|
||||
if err := client.ValidateConnection(ctx); err != nil {
|
||||
return nil, fmt.Errorf("failed to connect to SLURP: %w", err)
|
||||
}
|
||||
|
||||
integrationCtx, cancel := context.WithCancel(ctx)
|
||||
|
||||
integrator := &SlurpEventIntegrator{
|
||||
config: slurpConfig,
|
||||
client: client,
|
||||
pubsub: ps,
|
||||
eventMapping: config.GetHmmmToSlurpMapping(),
|
||||
decisionPublisher: decisionPublisher,
|
||||
eventBatch: make([]SlurpEvent, 0, slurpConfig.BatchProcessing.MaxBatchSize),
|
||||
ctx: integrationCtx,
|
||||
cancel: cancel,
|
||||
stats: SlurpIntegrationStats{},
|
||||
}
|
||||
|
||||
// Initialize batch processing if enabled
|
||||
if slurpConfig.BatchProcessing.Enabled {
|
||||
integrator.initBatchProcessing()
|
||||
}
|
||||
|
||||
fmt.Printf("🎯 SLURP Event Integrator initialized for %s\n", slurpConfig.BaseURL)
|
||||
return integrator, nil
|
||||
}
|
||||
|
||||
// ProcessHmmmDiscussion analyzes a HMMM discussion and generates appropriate SLURP events
|
||||
func (s *SlurpEventIntegrator) ProcessHmmmDiscussion(ctx context.Context, discussion HmmmDiscussionContext) error {
|
||||
s.statsMutex.Lock()
|
||||
s.stats.EventsGenerated++
|
||||
s.stats.LastEventTime = time.Now()
|
||||
s.statsMutex.Unlock()
|
||||
|
||||
// Validate discussion meets generation criteria
|
||||
if !s.shouldGenerateEvent(discussion) {
|
||||
fmt.Printf("📊 Discussion %s does not meet event generation criteria\n", discussion.DiscussionID)
|
||||
return nil
|
||||
}
|
||||
|
||||
// Determine event type from discussion
|
||||
eventType, confidence := s.determineEventType(discussion)
|
||||
if eventType == "" {
|
||||
fmt.Printf("📊 Could not determine event type for discussion %s\n", discussion.DiscussionID)
|
||||
return nil
|
||||
}
|
||||
|
||||
// Calculate severity
|
||||
severity := s.calculateSeverity(discussion, eventType)
|
||||
|
||||
// Generate event content
|
||||
content := s.generateEventContent(discussion)
|
||||
|
||||
// Generate UCXL address for this discussion
|
||||
ucxlAddr, err := s.generateUCXLAddress(discussion)
|
||||
if err != nil {
|
||||
fmt.Printf("⚠️ Failed to generate UCXL address: %v", err)
|
||||
// Continue without UCXL address if generation fails
|
||||
}
|
||||
|
||||
// Create SLURP event with UCXL enrichment
|
||||
slurpEvent := SlurpEvent{
|
||||
EventType: eventType,
|
||||
Path: discussion.ProjectPath,
|
||||
Content: content,
|
||||
Severity: severity,
|
||||
CreatedBy: s.config.DefaultEventSettings.DefaultCreatedBy,
|
||||
Timestamp: time.Now(),
|
||||
Tags: append(s.config.DefaultEventSettings.DefaultTags, fmt.Sprintf("confidence-%.2f", confidence)),
|
||||
Metadata: map[string]interface{}{
|
||||
"discussion_id": discussion.DiscussionID,
|
||||
"session_id": discussion.SessionID,
|
||||
"participants": discussion.Participants,
|
||||
"consensus_strength": discussion.ConsensusStrength,
|
||||
"discussion_duration": discussion.EndTime.Sub(discussion.StartTime).String(),
|
||||
"message_count": len(discussion.Messages),
|
||||
"outcome_type": discussion.OutcomeType,
|
||||
"generation_confidence": confidence,
|
||||
},
|
||||
}
|
||||
|
||||
// Add UCXL address components if successfully generated
|
||||
if ucxlAddr != nil {
|
||||
slurpEvent.Metadata["ucxl_reference"] = ucxlAddr.String()
|
||||
slurpEvent.Metadata["ucxl_agent"] = ucxlAddr.Agent
|
||||
slurpEvent.Metadata["ucxl_role"] = ucxlAddr.Role
|
||||
slurpEvent.Metadata["ucxl_project"] = ucxlAddr.Project
|
||||
slurpEvent.Metadata["ucxl_task"] = ucxlAddr.Task
|
||||
slurpEvent.Metadata["ucxl_temporal"] = ucxlAddr.TemporalSegment.String()
|
||||
if ucxlAddr.Path != "" {
|
||||
slurpEvent.Metadata["ucxl_path"] = ucxlAddr.Path
|
||||
}
|
||||
}
|
||||
|
||||
// Add custom metadata from template
|
||||
for key, value := range s.config.DefaultEventSettings.MetadataTemplate {
|
||||
slurpEvent.Metadata[key] = value
|
||||
}
|
||||
|
||||
// Add discussion-specific metadata
|
||||
for key, value := range discussion.Metadata {
|
||||
slurpEvent.Metadata[key] = value
|
||||
}
|
||||
|
||||
// Publish decision to DHT if UCXL address was successfully generated and decision publisher is available
|
||||
if ucxlAddr != nil && s.decisionPublisher != nil && s.decisionPublisher.IsEnabled() {
|
||||
if s.shouldPublishDecision(eventType) {
|
||||
decision := s.createDecisionFromDiscussion(discussion, eventType, confidence)
|
||||
publishResult, err := s.decisionPublisher.PublishDecision(ctx, ucxlAddr, decision)
|
||||
if err != nil {
|
||||
log.Printf("⚠️ Failed to publish decision to DHT: %v", err)
|
||||
} else if publishResult.Success {
|
||||
// Add DHT reference to event metadata
|
||||
slurpEvent.Metadata["decision_dht_hash"] = publishResult.DHTHash
|
||||
slurpEvent.Metadata["decision_published"] = true
|
||||
slurpEvent.Metadata["decision_published_at"] = publishResult.PublishedAt
|
||||
|
||||
log.Printf("📤 Decision published to DHT: %s", publishResult.DHTHash[:16]+"...")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Send event (batch or immediate)
|
||||
if s.config.BatchProcessing.Enabled {
|
||||
return s.addToBatch(slurpEvent)
|
||||
} else {
|
||||
return s.sendImmediateEvent(ctx, slurpEvent, discussion.DiscussionID)
|
||||
}
|
||||
}
|
||||
|
||||
// shouldGenerateEvent determines if a discussion meets the criteria for event generation
|
||||
func (s *SlurpEventIntegrator) shouldGenerateEvent(discussion HmmmDiscussionContext) bool {
|
||||
// Check minimum participants
|
||||
if len(discussion.Participants) < s.config.EventGeneration.MinParticipants {
|
||||
return false
|
||||
}
|
||||
|
||||
// Check consensus strength
|
||||
if discussion.ConsensusStrength < s.config.EventGeneration.MinConsensusStrength {
|
||||
return false
|
||||
}
|
||||
|
||||
// Check discussion duration
|
||||
duration := discussion.EndTime.Sub(discussion.StartTime)
|
||||
if duration < s.config.EventGeneration.MinDiscussionDuration {
|
||||
return false
|
||||
}
|
||||
|
||||
if duration > s.config.EventGeneration.MaxDiscussionDuration {
|
||||
return false // Too long, might indicate stalled discussion
|
||||
}
|
||||
|
||||
// Check if unanimity is required and achieved
|
||||
if s.config.EventGeneration.RequireUnanimity && discussion.ConsensusStrength < 1.0 {
|
||||
return false
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
// determineEventType analyzes discussion content to determine SLURP event type
|
||||
func (s *SlurpEventIntegrator) determineEventType(discussion HmmmDiscussionContext) (string, float64) {
|
||||
// Combine all message content for analysis
|
||||
var allContent strings.Builder
|
||||
for _, msg := range discussion.Messages {
|
||||
allContent.WriteString(strings.ToLower(msg.Content))
|
||||
allContent.WriteString(" ")
|
||||
}
|
||||
content := allContent.String()
|
||||
|
||||
// Score each event type based on keyword matches
|
||||
scores := make(map[string]float64)
|
||||
|
||||
scores["approval"] = s.scoreKeywordMatch(content, s.eventMapping.ApprovalKeywords)
|
||||
scores["warning"] = s.scoreKeywordMatch(content, s.eventMapping.WarningKeywords)
|
||||
scores["blocker"] = s.scoreKeywordMatch(content, s.eventMapping.BlockerKeywords)
|
||||
scores["priority_change"] = s.scoreKeywordMatch(content, s.eventMapping.PriorityKeywords)
|
||||
scores["access_update"] = s.scoreKeywordMatch(content, s.eventMapping.AccessKeywords)
|
||||
scores["structural_change"] = s.scoreKeywordMatch(content, s.eventMapping.StructuralKeywords)
|
||||
scores["announcement"] = s.scoreKeywordMatch(content, s.eventMapping.AnnouncementKeywords)
|
||||
|
||||
// Find highest scoring event type
|
||||
var bestType string
|
||||
var bestScore float64
|
||||
for eventType, score := range scores {
|
||||
if score > bestScore {
|
||||
bestType = eventType
|
||||
bestScore = score
|
||||
}
|
||||
}
|
||||
|
||||
// Require minimum confidence threshold
|
||||
minConfidence := 0.3
|
||||
if bestScore < minConfidence {
|
||||
return "", 0
|
||||
}
|
||||
|
||||
// Check if event type is enabled
|
||||
if s.isEventTypeDisabled(bestType) {
|
||||
return "", 0
|
||||
}
|
||||
|
||||
return bestType, bestScore
|
||||
}
|
||||
|
||||
// scoreKeywordMatch calculates a score based on keyword frequency
|
||||
func (s *SlurpEventIntegrator) scoreKeywordMatch(content string, keywords []string) float64 {
|
||||
if len(keywords) == 0 {
|
||||
return 0
|
||||
}
|
||||
|
||||
matches := 0
|
||||
for _, keyword := range keywords {
|
||||
if strings.Contains(content, strings.ToLower(keyword)) {
|
||||
matches++
|
||||
}
|
||||
}
|
||||
|
||||
return float64(matches) / float64(len(keywords))
|
||||
}
|
||||
|
||||
// isEventTypeDisabled checks if an event type is disabled in configuration
|
||||
func (s *SlurpEventIntegrator) isEventTypeDisabled(eventType string) bool {
|
||||
for _, disabled := range s.config.EventGeneration.DisabledEventTypes {
|
||||
if disabled == eventType {
|
||||
return true
|
||||
}
|
||||
}
|
||||
|
||||
// Check if it's in enabled list (if specified)
|
||||
if len(s.config.EventGeneration.EnabledEventTypes) > 0 {
|
||||
for _, enabled := range s.config.EventGeneration.EnabledEventTypes {
|
||||
if enabled == eventType {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true // Not in enabled list
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
|
||||
// calculateSeverity determines event severity based on discussion characteristics
|
||||
func (s *SlurpEventIntegrator) calculateSeverity(discussion HmmmDiscussionContext, eventType string) int {
|
||||
// Start with base severity for event type
|
||||
baseSeverity := s.config.EventGeneration.SeverityRules.BaseSeverity[eventType]
|
||||
if baseSeverity == 0 {
|
||||
baseSeverity = s.config.DefaultEventSettings.DefaultSeverity
|
||||
}
|
||||
|
||||
severity := float64(baseSeverity)
|
||||
|
||||
// Apply participant multiplier
|
||||
participantBoost := float64(len(discussion.Participants)-1) * s.config.EventGeneration.SeverityRules.ParticipantMultiplier
|
||||
severity += participantBoost
|
||||
|
||||
// Apply duration multiplier
|
||||
durationHours := discussion.EndTime.Sub(discussion.StartTime).Hours()
|
||||
durationBoost := durationHours * s.config.EventGeneration.SeverityRules.DurationMultiplier
|
||||
severity += durationBoost
|
||||
|
||||
// Check for urgency keywords
|
||||
allContent := strings.ToLower(s.generateEventContent(discussion))
|
||||
for _, keyword := range s.config.EventGeneration.SeverityRules.UrgencyKeywords {
|
||||
if strings.Contains(allContent, strings.ToLower(keyword)) {
|
||||
severity += float64(s.config.EventGeneration.SeverityRules.UrgencyBoost)
|
||||
break // Only apply once
|
||||
}
|
||||
}
|
||||
|
||||
// Apply bounds
|
||||
finalSeverity := int(math.Round(severity))
|
||||
if finalSeverity < s.config.EventGeneration.SeverityRules.MinSeverity {
|
||||
finalSeverity = s.config.EventGeneration.SeverityRules.MinSeverity
|
||||
}
|
||||
if finalSeverity > s.config.EventGeneration.SeverityRules.MaxSeverity {
|
||||
finalSeverity = s.config.EventGeneration.SeverityRules.MaxSeverity
|
||||
}
|
||||
|
||||
return finalSeverity
|
||||
}
|
||||
|
||||
// generateEventContent creates human-readable content for the SLURP event
|
||||
func (s *SlurpEventIntegrator) generateEventContent(discussion HmmmDiscussionContext) string {
|
||||
if discussion.OutcomeType != "" {
|
||||
return fmt.Sprintf("HMMM discussion reached consensus: %s (%d participants, %.1f%% agreement)",
|
||||
discussion.OutcomeType,
|
||||
len(discussion.Participants),
|
||||
discussion.ConsensusStrength*100)
|
||||
}
|
||||
|
||||
return fmt.Sprintf("HMMM discussion completed with %d participants over %v",
|
||||
len(discussion.Participants),
|
||||
discussion.EndTime.Sub(discussion.StartTime).Round(time.Minute))
|
||||
}
|
||||
|
||||
// addToBatch adds an event to the batch for later processing
|
||||
func (s *SlurpEventIntegrator) addToBatch(event SlurpEvent) error {
|
||||
s.batchMutex.Lock()
|
||||
defer s.batchMutex.Unlock()
|
||||
|
||||
s.eventBatch = append(s.eventBatch, event)
|
||||
|
||||
// Check if batch is full
|
||||
if len(s.eventBatch) >= s.config.BatchProcessing.MaxBatchSize {
|
||||
return s.flushBatch()
|
||||
}
|
||||
|
||||
// Reset batch timer
|
||||
if s.batchTimer != nil {
|
||||
s.batchTimer.Stop()
|
||||
}
|
||||
s.batchTimer = time.AfterFunc(s.config.BatchProcessing.MaxBatchWait, func() {
|
||||
s.batchMutex.Lock()
|
||||
defer s.batchMutex.Unlock()
|
||||
s.flushBatch()
|
||||
})
|
||||
|
||||
fmt.Printf("📦 Added event to batch (%d/%d)\n", len(s.eventBatch), s.config.BatchProcessing.MaxBatchSize)
|
||||
return nil
|
||||
}
|
||||
|
||||
// flushBatch sends all batched events to SLURP
|
||||
func (s *SlurpEventIntegrator) flushBatch() error {
|
||||
if len(s.eventBatch) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
events := make([]SlurpEvent, len(s.eventBatch))
|
||||
copy(events, s.eventBatch)
|
||||
s.eventBatch = s.eventBatch[:0] // Clear batch
|
||||
|
||||
if s.batchTimer != nil {
|
||||
s.batchTimer.Stop()
|
||||
s.batchTimer = nil
|
||||
}
|
||||
|
||||
fmt.Printf("🚀 Flushing batch of %d events to SLURP\n", len(events))
|
||||
|
||||
start := time.Now()
|
||||
resp, err := s.client.CreateEventsBatch(s.ctx, events)
|
||||
duration := time.Since(start)
|
||||
|
||||
s.statsMutex.Lock()
|
||||
s.stats.BatchesSent++
|
||||
s.stats.AverageResponseTime = (s.stats.AverageResponseTime + duration.Seconds()*1000) / 2
|
||||
|
||||
if err != nil {
|
||||
s.stats.EventsFailed += int64(len(events))
|
||||
s.stats.LastFailureTime = time.Now()
|
||||
s.stats.LastFailureError = err.Error()
|
||||
s.statsMutex.Unlock()
|
||||
|
||||
// Publish failure notification
|
||||
s.publishSlurpEvent("slurp_batch_failed", map[string]interface{}{
|
||||
"error": err.Error(),
|
||||
"event_count": len(events),
|
||||
"batch_id": fmt.Sprintf("batch_%d", time.Now().Unix()),
|
||||
})
|
||||
|
||||
return fmt.Errorf("failed to send batch: %w", err)
|
||||
}
|
||||
|
||||
s.stats.EventsSuccessful += int64(resp.ProcessedCount)
|
||||
s.stats.EventsFailed += int64(resp.FailedCount)
|
||||
s.stats.LastSuccessTime = time.Now()
|
||||
s.statsMutex.Unlock()
|
||||
|
||||
// Publish success notification
|
||||
s.publishSlurpEvent("slurp_batch_success", map[string]interface{}{
|
||||
"processed_count": resp.ProcessedCount,
|
||||
"failed_count": resp.FailedCount,
|
||||
"event_ids": resp.EventIDs,
|
||||
"batch_id": fmt.Sprintf("batch_%d", time.Now().Unix()),
|
||||
})
|
||||
|
||||
fmt.Printf("✅ Batch processed: %d succeeded, %d failed\n", resp.ProcessedCount, resp.FailedCount)
|
||||
return nil
|
||||
}
|
||||
|
||||
// sendImmediateEvent sends a single event immediately to SLURP
|
||||
func (s *SlurpEventIntegrator) sendImmediateEvent(ctx context.Context, event SlurpEvent, discussionID string) error {
|
||||
start := time.Now()
|
||||
resp, err := s.client.CreateEvent(ctx, event)
|
||||
duration := time.Since(start)
|
||||
|
||||
s.statsMutex.Lock()
|
||||
s.stats.AverageResponseTime = (s.stats.AverageResponseTime + duration.Seconds()*1000) / 2
|
||||
|
||||
if err != nil {
|
||||
s.stats.EventsFailed++
|
||||
s.stats.LastFailureTime = time.Now()
|
||||
s.stats.LastFailureError = err.Error()
|
||||
s.statsMutex.Unlock()
|
||||
|
||||
// Publish failure notification
|
||||
s.publishSlurpEvent("slurp_event_failed", map[string]interface{}{
|
||||
"discussion_id": discussionID,
|
||||
"event_type": event.EventType,
|
||||
"error": err.Error(),
|
||||
})
|
||||
|
||||
return fmt.Errorf("failed to send event: %w", err)
|
||||
}
|
||||
|
||||
s.stats.EventsSuccessful++
|
||||
s.stats.LastSuccessTime = time.Now()
|
||||
s.statsMutex.Unlock()
|
||||
|
||||
// Publish success notification
|
||||
s.publishSlurpEvent("slurp_event_success", map[string]interface{}{
|
||||
"discussion_id": discussionID,
|
||||
"event_type": event.EventType,
|
||||
"event_id": resp.EventID,
|
||||
"severity": event.Severity,
|
||||
})
|
||||
|
||||
fmt.Printf("✅ SLURP event created: %s (ID: %s)\n", event.EventType, resp.EventID)
|
||||
return nil
|
||||
}
|
||||
|
||||
// publishSlurpEvent publishes a SLURP integration event to the pubsub system
|
||||
func (s *SlurpEventIntegrator) publishSlurpEvent(eventType string, data map[string]interface{}) {
|
||||
var msgType pubsub.MessageType
|
||||
switch eventType {
|
||||
case "slurp_event_success", "slurp_batch_success":
|
||||
msgType = pubsub.SlurpEventGenerated
|
||||
case "slurp_event_failed", "slurp_batch_failed":
|
||||
msgType = pubsub.SlurpEventAck
|
||||
default:
|
||||
msgType = pubsub.SlurpContextUpdate
|
||||
}
|
||||
|
||||
data["timestamp"] = time.Now()
|
||||
data["integration_source"] = "hmmm-slurp-integrator"
|
||||
|
||||
if err := s.pubsub.PublishHmmmMessage(msgType, data); err != nil {
|
||||
fmt.Printf("❌ Failed to publish SLURP integration event: %v\n", err)
|
||||
}
|
||||
}
|
||||
|
||||
// initBatchProcessing initializes batch processing components
|
||||
func (s *SlurpEventIntegrator) initBatchProcessing() {
|
||||
fmt.Printf("📦 Batch processing enabled: max_size=%d, max_wait=%v\n",
|
||||
s.config.BatchProcessing.MaxBatchSize,
|
||||
s.config.BatchProcessing.MaxBatchWait)
|
||||
}
|
||||
|
||||
// GetStats returns current integration statistics
|
||||
func (s *SlurpEventIntegrator) GetStats() SlurpIntegrationStats {
|
||||
s.statsMutex.RLock()
|
||||
defer s.statsMutex.RUnlock()
|
||||
return s.stats
|
||||
}
|
||||
|
||||
// Close shuts down the integrator and flushes any pending events
|
||||
func (s *SlurpEventIntegrator) Close() error {
|
||||
s.cancel()
|
||||
|
||||
// Flush any remaining batched events
|
||||
if s.config.BatchProcessing.Enabled && s.config.BatchProcessing.FlushOnShutdown {
|
||||
s.batchMutex.Lock()
|
||||
if len(s.eventBatch) > 0 {
|
||||
fmt.Printf("🧹 Flushing %d remaining events on shutdown\n", len(s.eventBatch))
|
||||
s.flushBatch()
|
||||
}
|
||||
s.batchMutex.Unlock()
|
||||
}
|
||||
|
||||
if s.batchTimer != nil {
|
||||
s.batchTimer.Stop()
|
||||
}
|
||||
|
||||
return s.client.Close()
|
||||
}
|
||||
|
||||
// generateUCXLAddress creates a UCXL address from HMMM discussion context
|
||||
func (s *SlurpEventIntegrator) generateUCXLAddress(discussion HmmmDiscussionContext) (*ucxl.Address, error) {
|
||||
// Extract components from discussion
|
||||
agent := s.extractAgentFromParticipants(discussion.Participants)
|
||||
role := s.extractRoleFromDiscussion(discussion)
|
||||
project := s.extractProjectFromPath(discussion.ProjectPath)
|
||||
task := s.extractTaskFromDiscussion(discussion)
|
||||
|
||||
// Use latest temporal segment by default
|
||||
temporalSegment := "*^"
|
||||
|
||||
// Build UCXL address string
|
||||
addressStr := fmt.Sprintf("ucxl://%s:%s@%s:%s/%s",
|
||||
agent, role, project, task, temporalSegment)
|
||||
|
||||
// Add path if available
|
||||
if discussion.ProjectPath != "" {
|
||||
// Extract relative path for UCXL
|
||||
relativePath := s.extractRelativePath(discussion.ProjectPath)
|
||||
if relativePath != "" {
|
||||
addressStr += "/" + relativePath
|
||||
}
|
||||
}
|
||||
|
||||
// Parse and validate the address
|
||||
return ucxl.Parse(addressStr)
|
||||
}
|
||||
|
||||
// extractAgentFromParticipants determines the primary agent from participants
|
||||
func (s *SlurpEventIntegrator) extractAgentFromParticipants(participants []string) string {
|
||||
if len(participants) == 0 {
|
||||
return "any"
|
||||
}
|
||||
|
||||
// Use the first participant as the primary agent, or "consensus" for multiple
|
||||
if len(participants) == 1 {
|
||||
return s.normalizeIdentifier(participants[0])
|
||||
}
|
||||
|
||||
return "consensus"
|
||||
}
|
||||
|
||||
// extractRoleFromDiscussion determines the role from discussion context
|
||||
func (s *SlurpEventIntegrator) extractRoleFromDiscussion(discussion HmmmDiscussionContext) string {
|
||||
// Look for role hints in metadata
|
||||
if discussion.Metadata != nil {
|
||||
if role, exists := discussion.Metadata["primary_role"]; exists {
|
||||
if roleStr, ok := role.(string); ok {
|
||||
return s.normalizeIdentifier(roleStr)
|
||||
}
|
||||
}
|
||||
|
||||
// Check for role-specific keywords in outcome type
|
||||
switch discussion.OutcomeType {
|
||||
case "architecture_decision":
|
||||
return "architect"
|
||||
case "security_review":
|
||||
return "security"
|
||||
case "code_review":
|
||||
return "developer"
|
||||
case "deployment_decision":
|
||||
return "ops"
|
||||
default:
|
||||
return "contributor"
|
||||
}
|
||||
}
|
||||
|
||||
return "contributor"
|
||||
}
|
||||
|
||||
// extractProjectFromPath extracts project name from project path
|
||||
func (s *SlurpEventIntegrator) extractProjectFromPath(projectPath string) string {
|
||||
if projectPath == "" {
|
||||
return "unknown"
|
||||
}
|
||||
|
||||
// Split path and take the first segment as project
|
||||
parts := strings.Split(strings.Trim(projectPath, "/"), "/")
|
||||
if len(parts) > 0 && parts[0] != "" {
|
||||
return s.normalizeIdentifier(parts[0])
|
||||
}
|
||||
|
||||
return "unknown"
|
||||
}
|
||||
|
||||
// extractTaskFromDiscussion determines task from discussion context
|
||||
func (s *SlurpEventIntegrator) extractTaskFromDiscussion(discussion HmmmDiscussionContext) string {
|
||||
// First check for explicit task in related tasks
|
||||
if len(discussion.RelatedTasks) > 0 {
|
||||
return s.normalizeIdentifier(discussion.RelatedTasks[0])
|
||||
}
|
||||
|
||||
// Check metadata for task information
|
||||
if discussion.Metadata != nil {
|
||||
if task, exists := discussion.Metadata["task_id"]; exists {
|
||||
if taskStr, ok := task.(string); ok {
|
||||
return s.normalizeIdentifier(taskStr)
|
||||
}
|
||||
}
|
||||
|
||||
if feature, exists := discussion.Metadata["feature"]; exists {
|
||||
if featureStr, ok := feature.(string); ok {
|
||||
return s.normalizeIdentifier(featureStr)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Fall back to discussion ID as task identifier
|
||||
if discussion.DiscussionID != "" {
|
||||
return s.normalizeIdentifier("discussion-" + discussion.DiscussionID)
|
||||
}
|
||||
|
||||
return "general"
|
||||
}
|
||||
|
||||
// extractRelativePath extracts relative path from project path for UCXL
|
||||
func (s *SlurpEventIntegrator) extractRelativePath(projectPath string) string {
|
||||
if projectPath == "" {
|
||||
return ""
|
||||
}
|
||||
|
||||
// Remove leading slash and split
|
||||
trimmed := strings.Trim(projectPath, "/")
|
||||
parts := strings.Split(trimmed, "/")
|
||||
|
||||
// If we have more than just the project name, join the rest as relative path
|
||||
if len(parts) > 1 {
|
||||
return strings.Join(parts[1:], "/")
|
||||
}
|
||||
|
||||
return ""
|
||||
}
|
||||
|
||||
// normalizeIdentifier normalizes identifiers for UCXL compliance
|
||||
func (s *SlurpEventIntegrator) normalizeIdentifier(identifier string) string {
|
||||
if identifier == "" {
|
||||
return "unknown"
|
||||
}
|
||||
|
||||
// Convert to lowercase and replace invalid characters with underscores
|
||||
normalized := strings.ToLower(identifier)
|
||||
normalized = regexp.MustCompile(`[^a-zA-Z0-9_\-]`).ReplaceAllString(normalized, "_")
|
||||
|
||||
// Ensure it doesn't start with a number or special character
|
||||
if !regexp.MustCompile(`^[a-zA-Z_]`).MatchString(normalized) {
|
||||
normalized = "id_" + normalized
|
||||
}
|
||||
|
||||
// Truncate if too long (UCXL components should be reasonable length)
|
||||
if len(normalized) > 50 {
|
||||
normalized = normalized[:50]
|
||||
}
|
||||
|
||||
return normalized
|
||||
}
|
||||
|
||||
// shouldPublishDecision determines if an event type warrants decision publication
|
||||
func (s *SlurpEventIntegrator) shouldPublishDecision(eventType string) bool {
|
||||
// Only publish decisions for conclusive outcomes
|
||||
decisiveEventTypes := []string{
|
||||
"approval",
|
||||
"blocker",
|
||||
"structural_change",
|
||||
"priority_change",
|
||||
"access_update",
|
||||
}
|
||||
|
||||
for _, decisive := range decisiveEventTypes {
|
||||
if eventType == decisive {
|
||||
return true
|
||||
}
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
|
||||
// createDecisionFromDiscussion creates a Decision object from HMMM discussion context
|
||||
func (s *SlurpEventIntegrator) createDecisionFromDiscussion(discussion HmmmDiscussionContext, eventType string, confidence float64) *Decision {
|
||||
decision := &Decision{
|
||||
Type: eventType,
|
||||
Content: s.generateEventContent(discussion),
|
||||
Participants: discussion.Participants,
|
||||
ConsensusLevel: discussion.ConsensusStrength,
|
||||
Timestamp: time.Now(),
|
||||
DiscussionID: discussion.DiscussionID,
|
||||
Confidence: confidence,
|
||||
Tags: []string{"hmmm-generated", "consensus-based", eventType},
|
||||
Metadata: map[string]interface{}{
|
||||
"session_id": discussion.SessionID,
|
||||
"discussion_duration": discussion.EndTime.Sub(discussion.StartTime).String(),
|
||||
"message_count": len(discussion.Messages),
|
||||
"outcome_type": discussion.OutcomeType,
|
||||
"project_path": discussion.ProjectPath,
|
||||
"related_tasks": discussion.RelatedTasks,
|
||||
"generation_source": "slurp-event-integrator",
|
||||
"generation_timestamp": time.Now(),
|
||||
},
|
||||
}
|
||||
|
||||
// Add discussion metadata to decision metadata
|
||||
if discussion.Metadata != nil {
|
||||
for key, value := range discussion.Metadata {
|
||||
decision.Metadata["discussion_"+key] = value
|
||||
}
|
||||
}
|
||||
|
||||
// Set expiration for temporary decisions (warnings, announcements)
|
||||
if eventType == "warning" || eventType == "announcement" {
|
||||
expiration := time.Now().Add(30 * 24 * time.Hour) // 30 days
|
||||
decision.ExpiresAt = &expiration
|
||||
}
|
||||
|
||||
return decision
|
||||
}
|
||||
Reference in New Issue
Block a user