566 lines
18 KiB
Go
566 lines
18 KiB
Go
package temporal
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"time"
|
|
|
|
slurpContext "chorus/pkg/slurp/context"
|
|
"chorus/pkg/slurp/storage"
|
|
"chorus/pkg/ucxl"
|
|
)
|
|
|
|
// TemporalGraphFactory creates and configures temporal graph components
|
|
type TemporalGraphFactory struct {
|
|
storage storage.ContextStore
|
|
config *TemporalConfig
|
|
}
|
|
|
|
// TemporalConfig represents configuration for the temporal graph system
|
|
type TemporalConfig struct {
|
|
// Core graph settings
|
|
MaxDepth int `json:"max_depth"`
|
|
StalenessWeights *StalenessWeights `json:"staleness_weights"`
|
|
CacheTimeout time.Duration `json:"cache_timeout"`
|
|
|
|
// Analysis settings
|
|
InfluenceAnalysisConfig *InfluenceAnalysisConfig `json:"influence_analysis_config"`
|
|
NavigationConfig *NavigationConfig `json:"navigation_config"`
|
|
QueryConfig *QueryConfig `json:"query_config"`
|
|
|
|
// Persistence settings
|
|
PersistenceConfig *PersistenceConfig `json:"persistence_config"`
|
|
|
|
// Performance settings
|
|
EnableCaching bool `json:"enable_caching"`
|
|
EnableCompression bool `json:"enable_compression"`
|
|
EnableMetrics bool `json:"enable_metrics"`
|
|
|
|
// Debug settings
|
|
EnableDebugLogging bool `json:"enable_debug_logging"`
|
|
EnableValidation bool `json:"enable_validation"`
|
|
}
|
|
|
|
// InfluenceAnalysisConfig represents configuration for influence analysis
|
|
type InfluenceAnalysisConfig struct {
|
|
DampingFactor float64 `json:"damping_factor"`
|
|
MaxIterations int `json:"max_iterations"`
|
|
ConvergenceThreshold float64 `json:"convergence_threshold"`
|
|
CacheValidDuration time.Duration `json:"cache_valid_duration"`
|
|
EnableCentralityMetrics bool `json:"enable_centrality_metrics"`
|
|
EnableCommunityDetection bool `json:"enable_community_detection"`
|
|
}
|
|
|
|
// NavigationConfig represents configuration for decision navigation
|
|
type NavigationConfig struct {
|
|
MaxNavigationHistory int `json:"max_navigation_history"`
|
|
BookmarkRetention time.Duration `json:"bookmark_retention"`
|
|
SessionTimeout time.Duration `json:"session_timeout"`
|
|
EnablePathCaching bool `json:"enable_path_caching"`
|
|
}
|
|
|
|
// QueryConfig represents configuration for decision-hop queries
|
|
type QueryConfig struct {
|
|
DefaultMaxHops int `json:"default_max_hops"`
|
|
MaxQueryResults int `json:"max_query_results"`
|
|
QueryTimeout time.Duration `json:"query_timeout"`
|
|
CacheQueryResults bool `json:"cache_query_results"`
|
|
EnableQueryOptimization bool `json:"enable_query_optimization"`
|
|
}
|
|
|
|
// TemporalGraphSystem represents the complete temporal graph system
|
|
type TemporalGraphSystem struct {
|
|
Graph TemporalGraph
|
|
Navigator DecisionNavigator
|
|
InfluenceAnalyzer InfluenceAnalyzer
|
|
StalenessDetector StalenessDetector
|
|
ConflictDetector ConflictDetector
|
|
PatternAnalyzer PatternAnalyzer
|
|
VersionManager VersionManager
|
|
HistoryManager HistoryManager
|
|
MetricsCollector MetricsCollector
|
|
QuerySystem *querySystemImpl
|
|
PersistenceManager *persistenceManagerImpl
|
|
}
|
|
|
|
// NewTemporalGraphFactory creates a new temporal graph factory
|
|
func NewTemporalGraphFactory(storage storage.ContextStore, config *TemporalConfig) *TemporalGraphFactory {
|
|
if config == nil {
|
|
config = DefaultTemporalConfig()
|
|
}
|
|
|
|
return &TemporalGraphFactory{
|
|
storage: storage,
|
|
config: config,
|
|
}
|
|
}
|
|
|
|
// CreateTemporalGraphSystem creates a complete temporal graph system
|
|
func (tgf *TemporalGraphFactory) CreateTemporalGraphSystem(
|
|
localStorage storage.LocalStorage,
|
|
distributedStorage storage.DistributedStorage,
|
|
encryptedStorage storage.EncryptedStorage,
|
|
backupManager storage.BackupManager,
|
|
) (*TemporalGraphSystem, error) {
|
|
|
|
// Create core temporal graph
|
|
graph := NewTemporalGraph(tgf.storage).(*temporalGraphImpl)
|
|
|
|
// Create navigator
|
|
navigator := NewDecisionNavigator(graph)
|
|
|
|
// Create influence analyzer
|
|
analyzer := NewInfluenceAnalyzer(graph)
|
|
|
|
// Create staleness detector
|
|
detector := NewStalenessDetector(graph)
|
|
|
|
// Create query system
|
|
querySystem := NewQuerySystem(graph, navigator, analyzer, detector)
|
|
|
|
// Create persistence manager
|
|
persistenceManager := NewPersistenceManager(
|
|
tgf.storage,
|
|
localStorage,
|
|
distributedStorage,
|
|
encryptedStorage,
|
|
backupManager,
|
|
graph,
|
|
tgf.config.PersistenceConfig,
|
|
)
|
|
|
|
// Create additional components
|
|
conflictDetector := NewConflictDetector(graph)
|
|
patternAnalyzer := NewPatternAnalyzer(graph)
|
|
versionManager := NewVersionManager(graph, persistenceManager)
|
|
historyManager := NewHistoryManager(graph, persistenceManager)
|
|
metricsCollector := NewMetricsCollector(graph)
|
|
|
|
system := &TemporalGraphSystem{
|
|
Graph: graph,
|
|
Navigator: navigator,
|
|
InfluenceAnalyzer: analyzer,
|
|
StalenessDetector: detector,
|
|
ConflictDetector: conflictDetector,
|
|
PatternAnalyzer: patternAnalyzer,
|
|
VersionManager: versionManager,
|
|
HistoryManager: historyManager,
|
|
MetricsCollector: metricsCollector,
|
|
QuerySystem: querySystem,
|
|
PersistenceManager: persistenceManager,
|
|
}
|
|
|
|
return system, nil
|
|
}
|
|
|
|
// LoadExistingSystem loads an existing temporal graph system from storage
|
|
func (tgf *TemporalGraphFactory) LoadExistingSystem(
|
|
ctx context.Context,
|
|
localStorage storage.LocalStorage,
|
|
distributedStorage storage.DistributedStorage,
|
|
encryptedStorage storage.EncryptedStorage,
|
|
backupManager storage.BackupManager,
|
|
) (*TemporalGraphSystem, error) {
|
|
|
|
// Create system
|
|
system, err := tgf.CreateTemporalGraphSystem(localStorage, distributedStorage, encryptedStorage, backupManager)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to create system: %w", err)
|
|
}
|
|
|
|
// Load graph data
|
|
err = system.PersistenceManager.LoadTemporalGraph(ctx)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to load temporal graph: %w", err)
|
|
}
|
|
|
|
return system, nil
|
|
}
|
|
|
|
// DefaultTemporalConfig returns default configuration for temporal graph
|
|
func DefaultTemporalConfig() *TemporalConfig {
|
|
return &TemporalConfig{
|
|
MaxDepth: 100,
|
|
StalenessWeights: &StalenessWeights{
|
|
TimeWeight: 0.3,
|
|
InfluenceWeight: 0.4,
|
|
ActivityWeight: 0.2,
|
|
ImportanceWeight: 0.1,
|
|
ComplexityWeight: 0.1,
|
|
DependencyWeight: 0.3,
|
|
},
|
|
CacheTimeout: time.Minute * 15,
|
|
|
|
InfluenceAnalysisConfig: &InfluenceAnalysisConfig{
|
|
DampingFactor: 0.85,
|
|
MaxIterations: 100,
|
|
ConvergenceThreshold: 1e-6,
|
|
CacheValidDuration: time.Minute * 30,
|
|
EnableCentralityMetrics: true,
|
|
EnableCommunityDetection: true,
|
|
},
|
|
|
|
NavigationConfig: &NavigationConfig{
|
|
MaxNavigationHistory: 100,
|
|
BookmarkRetention: time.Hour * 24 * 30, // 30 days
|
|
SessionTimeout: time.Hour * 2,
|
|
EnablePathCaching: true,
|
|
},
|
|
|
|
QueryConfig: &QueryConfig{
|
|
DefaultMaxHops: 10,
|
|
MaxQueryResults: 1000,
|
|
QueryTimeout: time.Second * 30,
|
|
CacheQueryResults: true,
|
|
EnableQueryOptimization: true,
|
|
},
|
|
|
|
PersistenceConfig: &PersistenceConfig{
|
|
EnableLocalStorage: true,
|
|
EnableDistributedStorage: true,
|
|
EnableEncryption: true,
|
|
EncryptionRoles: []string{"analyst", "architect", "developer"},
|
|
SyncInterval: time.Minute * 15,
|
|
ConflictResolutionStrategy: "latest_wins",
|
|
EnableAutoSync: true,
|
|
MaxSyncRetries: 3,
|
|
BatchSize: 50,
|
|
FlushInterval: time.Second * 30,
|
|
EnableWriteBuffer: true,
|
|
EnableAutoBackup: true,
|
|
BackupInterval: time.Hour * 6,
|
|
RetainBackupCount: 10,
|
|
KeyPrefix: "temporal_graph",
|
|
NodeKeyPattern: "temporal_graph/nodes/%s",
|
|
GraphKeyPattern: "temporal_graph/graph/%s",
|
|
MetadataKeyPattern: "temporal_graph/metadata/%s",
|
|
},
|
|
|
|
EnableCaching: true,
|
|
EnableCompression: false,
|
|
EnableMetrics: true,
|
|
EnableDebugLogging: false,
|
|
EnableValidation: true,
|
|
}
|
|
}
|
|
|
|
// Component factory functions
|
|
|
|
func NewConflictDetector(graph *temporalGraphImpl) ConflictDetector {
|
|
return &conflictDetectorImpl{
|
|
graph: graph,
|
|
}
|
|
}
|
|
|
|
func NewPatternAnalyzer(graph *temporalGraphImpl) PatternAnalyzer {
|
|
return &patternAnalyzerImpl{
|
|
graph: graph,
|
|
}
|
|
}
|
|
|
|
func NewVersionManager(graph *temporalGraphImpl, persistence *persistenceManagerImpl) VersionManager {
|
|
return &versionManagerImpl{
|
|
graph: graph,
|
|
persistence: persistence,
|
|
}
|
|
}
|
|
|
|
func NewHistoryManager(graph *temporalGraphImpl, persistence *persistenceManagerImpl) HistoryManager {
|
|
return &historyManagerImpl{
|
|
graph: graph,
|
|
persistence: persistence,
|
|
}
|
|
}
|
|
|
|
func NewMetricsCollector(graph *temporalGraphImpl) MetricsCollector {
|
|
return &metricsCollectorImpl{
|
|
graph: graph,
|
|
}
|
|
}
|
|
|
|
// Basic implementations for the remaining interfaces
|
|
|
|
type conflictDetectorImpl struct {
|
|
graph *temporalGraphImpl
|
|
}
|
|
|
|
func (cd *conflictDetectorImpl) DetectTemporalConflicts(ctx context.Context) ([]*TemporalConflict, error) {
|
|
// Implementation would scan for conflicts in temporal data
|
|
return make([]*TemporalConflict, 0), nil
|
|
}
|
|
|
|
func (cd *conflictDetectorImpl) DetectInconsistentDecisions(ctx context.Context) ([]*DecisionInconsistency, error) {
|
|
// Implementation would detect inconsistent decision metadata
|
|
return make([]*DecisionInconsistency, 0), nil
|
|
}
|
|
|
|
func (cd *conflictDetectorImpl) ValidateDecisionSequence(ctx context.Context, address ucxl.Address) (*SequenceValidation, error) {
|
|
// Implementation would validate decision sequence for logical consistency
|
|
return &SequenceValidation{
|
|
Address: address,
|
|
Valid: true,
|
|
Issues: make([]string, 0),
|
|
Warnings: make([]string, 0),
|
|
ValidatedAt: time.Now(),
|
|
SequenceLength: 0,
|
|
IntegrityScore: 1.0,
|
|
}, nil
|
|
}
|
|
|
|
func (cd *conflictDetectorImpl) ResolveTemporalConflict(ctx context.Context, conflict *TemporalConflict) (*ConflictResolution, error) {
|
|
// Implementation would resolve specific temporal conflicts
|
|
return &ConflictResolution{
|
|
ConflictID: conflict.ID,
|
|
ResolutionMethod: "auto_resolved",
|
|
ResolvedAt: time.Now(),
|
|
ResolvedBy: "system",
|
|
Confidence: 0.8,
|
|
}, nil
|
|
}
|
|
|
|
func (cd *conflictDetectorImpl) GetConflictResolutionHistory(ctx context.Context, address ucxl.Address) ([]*ConflictResolution, error) {
|
|
// Implementation would return history of resolved conflicts
|
|
return make([]*ConflictResolution, 0), nil
|
|
}
|
|
|
|
type patternAnalyzerImpl struct {
|
|
graph *temporalGraphImpl
|
|
}
|
|
|
|
func (pa *patternAnalyzerImpl) AnalyzeDecisionPatterns(ctx context.Context) ([]*DecisionPattern, error) {
|
|
// Implementation would identify patterns in decision-making
|
|
return make([]*DecisionPattern, 0), nil
|
|
}
|
|
|
|
func (pa *patternAnalyzerImpl) AnalyzeEvolutionPatterns(ctx context.Context) ([]*EvolutionPattern, error) {
|
|
// Implementation would identify patterns in context evolution
|
|
return make([]*EvolutionPattern, 0), nil
|
|
}
|
|
|
|
func (pa *patternAnalyzerImpl) DetectAnomalousDecisions(ctx context.Context) ([]*AnomalousDecision, error) {
|
|
// Implementation would detect unusual decision patterns
|
|
return make([]*AnomalousDecision, 0), nil
|
|
}
|
|
|
|
func (pa *patternAnalyzerImpl) PredictNextDecision(ctx context.Context, address ucxl.Address) ([]*DecisionPrediction, error) {
|
|
// Implementation would predict likely next decisions
|
|
return make([]*DecisionPrediction, 0), nil
|
|
}
|
|
|
|
func (pa *patternAnalyzerImpl) LearnFromHistory(ctx context.Context, timeRange time.Duration) (*LearningResult, error) {
|
|
// Implementation would learn patterns from historical data
|
|
return &LearningResult{
|
|
TimeRange: timeRange,
|
|
PatternsLearned: 0,
|
|
NewPatterns: make([]*DecisionPattern, 0),
|
|
UpdatedPatterns: make([]*DecisionPattern, 0),
|
|
LearnedAt: time.Now(),
|
|
}, nil
|
|
}
|
|
|
|
func (pa *patternAnalyzerImpl) GetPatternStats() (*PatternStatistics, error) {
|
|
// Implementation would return pattern analysis statistics
|
|
return &PatternStatistics{
|
|
TotalPatterns: 0,
|
|
PatternsByType: make(map[PatternType]int),
|
|
AverageConfidence: 0.0,
|
|
MostFrequentPatterns: make([]*DecisionPattern, 0),
|
|
RecentPatterns: make([]*DecisionPattern, 0),
|
|
LastAnalysisAt: time.Now(),
|
|
}, nil
|
|
}
|
|
|
|
type versionManagerImpl struct {
|
|
graph *temporalGraphImpl
|
|
persistence *persistenceManagerImpl
|
|
}
|
|
|
|
func (vm *versionManagerImpl) CreateVersion(ctx context.Context, address ucxl.Address,
|
|
contextNode *slurpContext.ContextNode, metadata *VersionMetadata) (*TemporalNode, error) {
|
|
// Implementation would create a new temporal version
|
|
return vm.graph.EvolveContext(ctx, address, contextNode, metadata.Reason, metadata.Decision)
|
|
}
|
|
|
|
func (vm *versionManagerImpl) GetVersion(ctx context.Context, address ucxl.Address, version int) (*TemporalNode, error) {
|
|
// Implementation would retrieve a specific version
|
|
return vm.graph.GetVersionAtDecision(ctx, address, version)
|
|
}
|
|
|
|
func (vm *versionManagerImpl) ListVersions(ctx context.Context, address ucxl.Address) ([]*VersionInfo, error) {
|
|
// Implementation would list all versions for a context
|
|
history, err := vm.graph.GetEvolutionHistory(ctx, address)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
versions := make([]*VersionInfo, len(history))
|
|
for i, node := range history {
|
|
versions[i] = &VersionInfo{
|
|
Address: node.UCXLAddress,
|
|
Version: node.Version,
|
|
CreatedAt: node.Timestamp,
|
|
Creator: "unknown", // Would get from decision metadata
|
|
ChangeReason: node.ChangeReason,
|
|
DecisionID: node.DecisionID,
|
|
}
|
|
}
|
|
|
|
return versions, nil
|
|
}
|
|
|
|
func (vm *versionManagerImpl) CompareVersions(ctx context.Context, address ucxl.Address,
|
|
version1, version2 int) (*VersionComparison, error) {
|
|
// Implementation would compare two temporal versions
|
|
return &VersionComparison{
|
|
Address: address,
|
|
Version1: version1,
|
|
Version2: version2,
|
|
Differences: make([]*VersionDiff, 0),
|
|
Similarity: 1.0,
|
|
ChangedFields: make([]string, 0),
|
|
ComparedAt: time.Now(),
|
|
}, nil
|
|
}
|
|
|
|
func (vm *versionManagerImpl) MergeVersions(ctx context.Context, address ucxl.Address,
|
|
versions []int, strategy MergeStrategy) (*TemporalNode, error) {
|
|
// Implementation would merge multiple versions
|
|
return vm.graph.GetLatestVersion(ctx, address)
|
|
}
|
|
|
|
func (vm *versionManagerImpl) TagVersion(ctx context.Context, address ucxl.Address, version int, tags []string) error {
|
|
// Implementation would add tags to a version
|
|
return nil
|
|
}
|
|
|
|
func (vm *versionManagerImpl) GetVersionTags(ctx context.Context, address ucxl.Address, version int) ([]string, error) {
|
|
// Implementation would get tags for a version
|
|
return make([]string, 0), nil
|
|
}
|
|
|
|
type historyManagerImpl struct {
|
|
graph *temporalGraphImpl
|
|
persistence *persistenceManagerImpl
|
|
}
|
|
|
|
func (hm *historyManagerImpl) GetFullHistory(ctx context.Context, address ucxl.Address) (*ContextHistory, error) {
|
|
// Implementation would get complete history for a context
|
|
history, err := hm.graph.GetEvolutionHistory(ctx, address)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &ContextHistory{
|
|
Address: address,
|
|
Versions: history,
|
|
GeneratedAt: time.Now(),
|
|
}, nil
|
|
}
|
|
|
|
func (hm *historyManagerImpl) GetHistoryRange(ctx context.Context, address ucxl.Address,
|
|
startHop, endHop int) (*ContextHistory, error) {
|
|
// Implementation would get history within a specific range
|
|
return hm.GetFullHistory(ctx, address)
|
|
}
|
|
|
|
func (hm *historyManagerImpl) SearchHistory(ctx context.Context, criteria *HistorySearchCriteria) ([]*HistoryMatch, error) {
|
|
// Implementation would search history using criteria
|
|
return make([]*HistoryMatch, 0), nil
|
|
}
|
|
|
|
func (hm *historyManagerImpl) ExportHistory(ctx context.Context, address ucxl.Address, format string) ([]byte, error) {
|
|
// Implementation would export history in various formats
|
|
return []byte{}, nil
|
|
}
|
|
|
|
func (hm *historyManagerImpl) ImportHistory(ctx context.Context, address ucxl.Address, data []byte, format string) error {
|
|
// Implementation would import history from external sources
|
|
return nil
|
|
}
|
|
|
|
func (hm *historyManagerImpl) ArchiveHistory(ctx context.Context, beforeTime time.Time) (*ArchiveResult, error) {
|
|
// Implementation would archive old history data
|
|
return &ArchiveResult{
|
|
ArchiveID: fmt.Sprintf("archive-%d", time.Now().Unix()),
|
|
ArchivedAt: time.Now(),
|
|
ItemsArchived: 0,
|
|
}, nil
|
|
}
|
|
|
|
func (hm *historyManagerImpl) RestoreHistory(ctx context.Context, archiveID string) (*RestoreResult, error) {
|
|
// Implementation would restore archived history data
|
|
return &RestoreResult{
|
|
ArchiveID: archiveID,
|
|
RestoredAt: time.Now(),
|
|
ItemsRestored: 0,
|
|
}, nil
|
|
}
|
|
|
|
type metricsCollectorImpl struct {
|
|
graph *temporalGraphImpl
|
|
}
|
|
|
|
func (mc *metricsCollectorImpl) CollectTemporalMetrics(ctx context.Context) (*TemporalMetrics, error) {
|
|
// Implementation would collect comprehensive temporal metrics
|
|
return &TemporalMetrics{
|
|
TotalNodes: len(mc.graph.nodes),
|
|
TotalDecisions: len(mc.graph.decisions),
|
|
ActiveContexts: len(mc.graph.addressToNodes),
|
|
InfluenceConnections: mc.calculateInfluenceConnections(),
|
|
CollectedAt: time.Now(),
|
|
}, nil
|
|
}
|
|
|
|
func (mc *metricsCollectorImpl) GetDecisionVelocity(ctx context.Context, timeWindow time.Duration) (*VelocityMetrics, error) {
|
|
// Implementation would calculate decision-making velocity
|
|
return &VelocityMetrics{
|
|
DecisionsPerHour: 0.0,
|
|
DecisionsPerDay: 0.0,
|
|
DecisionsPerWeek: 0.0,
|
|
TimeWindow: timeWindow,
|
|
}, nil
|
|
}
|
|
|
|
func (mc *metricsCollectorImpl) GetEvolutionMetrics(ctx context.Context) (*EvolutionMetrics, error) {
|
|
// Implementation would get context evolution metrics
|
|
return &EvolutionMetrics{
|
|
ContextsEvolved: 0,
|
|
AverageEvolutions: 0.0,
|
|
MajorEvolutions: 0,
|
|
MinorEvolutions: 0,
|
|
}, nil
|
|
}
|
|
|
|
func (mc *metricsCollectorImpl) GetInfluenceMetrics(ctx context.Context) (*InfluenceMetrics, error) {
|
|
// Implementation would get influence relationship metrics
|
|
return &InfluenceMetrics{
|
|
TotalRelationships: mc.calculateInfluenceConnections(),
|
|
}, nil
|
|
}
|
|
|
|
func (mc *metricsCollectorImpl) GetQualityMetrics(ctx context.Context) (*QualityMetrics, error) {
|
|
// Implementation would get temporal data quality metrics
|
|
return &QualityMetrics{
|
|
DataCompleteness: 1.0,
|
|
DataConsistency: 1.0,
|
|
DataAccuracy: 1.0,
|
|
AverageConfidence: 0.8,
|
|
ConflictsDetected: 0,
|
|
ConflictsResolved: 0,
|
|
LastQualityCheck: time.Now(),
|
|
}, nil
|
|
}
|
|
|
|
func (mc *metricsCollectorImpl) ResetMetrics(ctx context.Context) error {
|
|
// Implementation would reset all collected metrics
|
|
return nil
|
|
}
|
|
|
|
func (mc *metricsCollectorImpl) calculateInfluenceConnections() int {
|
|
total := 0
|
|
for _, influences := range mc.graph.influences {
|
|
total += len(influences)
|
|
}
|
|
return total
|
|
}
|