tony/CHORUS
1
0
Fork 0
Code Issues 10 Pull Requests Actions Packages Projects Releases Wiki Activity

Fix temporal persistence wiring and restore slurp_full suite

Browse Source
This commit is contained in:
anthonyrawlins
2025-09-28 11:39:03 +10:00
parent 9c32755632
commit 2ff408729c
16 changed files with 1195 additions and 802 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
pkg/slurp/storage/errors.go Normal file
View File

@@ -0,0 +1,8 @@
package storage
import "errors"
// ErrNotFound indicates that the requested context does not exist in storage.
// Tests and higher-level components rely on this sentinel for consistent handling
// across local, distributed, and encrypted backends.
var ErrNotFound = errors.New("storage: not found")

4
pkg/slurp/storage/local_storage.go
View File

@@ -201,7 +201,7 @@ func (ls *LocalStorageImpl) Retrieve(ctx context.Context, key string) (interface
entryBytes, err := ls.db.Get([]byte(key), nil)
if err != nil {
if err == leveldb.ErrNotFound {
return nil, fmt.Errorf("key not found: %s", key)
return nil, fmt.Errorf("%w: %s", ErrNotFound, key)
}
return nil, fmt.Errorf("failed to retrieve data: %w", err)
}
@@ -328,7 +328,7 @@ func (ls *LocalStorageImpl) Size(ctx context.Context, key string) (int64, error)
entryBytes, err := ls.db.Get([]byte(key), nil)
if err != nil {
if err == leveldb.ErrNotFound {
return 0, fmt.Errorf("key not found: %s", key)
return 0, fmt.Errorf("%w: %s", ErrNotFound, key)
}
return 0, fmt.Errorf("failed to get data size: %w", err)
}

161
pkg/slurp/temporal/graph_impl.go
View File

@@ -19,7 +19,8 @@ type temporalGraphImpl struct {
mu sync.RWMutex
// Core storage
storage storage.ContextStore
storage storage.ContextStore
persistence nodePersister
// In-memory graph structures for fast access
nodes map[string]*TemporalNode // nodeID -> TemporalNode
@@ -42,6 +43,10 @@ type temporalGraphImpl struct {
stalenessWeight *StalenessWeights
}
type nodePersister interface {
PersistTemporalNode(ctx context.Context, node *TemporalNode) error
}
// NewTemporalGraph creates a new temporal graph implementation
func NewTemporalGraph(storage storage.ContextStore) TemporalGraph {
return &temporalGraphImpl{
@@ -177,16 +182,40 @@ func (tg *temporalGraphImpl) EvolveContext(ctx context.Context, address ucxl.Add
}
// Copy influence relationships from parent
if len(latestNode.Influences) > 0 {
temporalNode.Influences = append([]ucxl.Address(nil), latestNode.Influences...)
} else {
temporalNode.Influences = make([]ucxl.Address, 0)
}
if len(latestNode.InfluencedBy) > 0 {
temporalNode.InfluencedBy = append([]ucxl.Address(nil), latestNode.InfluencedBy...)
} else {
temporalNode.InfluencedBy = make([]ucxl.Address, 0)
}
if latestNodeInfluences, exists := tg.influences[latestNode.ID]; exists {
tg.influences[nodeID] = make([]string, len(latestNodeInfluences))
copy(tg.influences[nodeID], latestNodeInfluences)
cloned := append([]string(nil), latestNodeInfluences...)
tg.influences[nodeID] = cloned
for _, targetID := range cloned {
tg.influencedBy[targetID] = ensureString(tg.influencedBy[targetID], nodeID)
if targetNode, ok := tg.nodes[targetID]; ok {
targetNode.InfluencedBy = ensureAddress(targetNode.InfluencedBy, address)
}
}
} else {
tg.influences[nodeID] = make([]string, 0)
}
if latestNodeInfluencedBy, exists := tg.influencedBy[latestNode.ID]; exists {
tg.influencedBy[nodeID] = make([]string, len(latestNodeInfluencedBy))
copy(tg.influencedBy[nodeID], latestNodeInfluencedBy)
cloned := append([]string(nil), latestNodeInfluencedBy...)
tg.influencedBy[nodeID] = cloned
for _, sourceID := range cloned {
tg.influences[sourceID] = ensureString(tg.influences[sourceID], nodeID)
if sourceNode, ok := tg.nodes[sourceID]; ok {
sourceNode.Influences = ensureAddress(sourceNode.Influences, address)
}
}
} else {
tg.influencedBy[nodeID] = make([]string, 0)
}
@@ -534,8 +563,7 @@ func (tg *temporalGraphImpl) FindDecisionPath(ctx context.Context, from, to ucxl
return nil, fmt.Errorf("from node not found: %w", err)
}
_, err := tg.getLatestNodeUnsafe(to)
if err != nil {
if _, err := tg.getLatestNodeUnsafe(to); err != nil {
return nil, fmt.Errorf("to node not found: %w", err)
}
@@ -750,31 +778,73 @@ func (tg *temporalGraphImpl) CompactHistory(ctx context.Context, beforeTime time
compacted := 0
// For each address, keep only the latest version and major milestones before the cutoff
for address, nodes := range tg.addressToNodes {
toKeep := make([]*TemporalNode, 0)
if len(nodes) == 0 {
continue
}
latestNode := nodes[len(nodes)-1]
toKeep := make([]*TemporalNode, 0, len(nodes))
toRemove := make([]*TemporalNode, 0)
for _, node := range nodes {
// Always keep nodes after the cutoff time
if node.Timestamp.After(beforeTime) {
if node == latestNode {
toKeep = append(toKeep, node)
continue
}
// Keep major changes and influential decisions
if tg.isMajorChange(node) || tg.isInfluentialDecision(node) {
if node.Timestamp.After(beforeTime) || tg.isMajorChange(node) || tg.isInfluentialDecision(node) {
toKeep = append(toKeep, node)
} else {
toRemove = append(toRemove, node)
continue
}
toRemove = append(toRemove, node)
}
// Update the address mapping
if len(toKeep) == 0 {
toKeep = append(toKeep, latestNode)
}
sort.Slice(toKeep, func(i, j int) bool {
return toKeep[i].Version < toKeep[j].Version
})
tg.addressToNodes[address] = toKeep
// Remove old nodes from main maps
for _, node := range toRemove {
if outgoing, exists := tg.influences[node.ID]; exists {
for _, targetID := range outgoing {
tg.influencedBy[targetID] = tg.removeFromSlice(tg.influencedBy[targetID], node.ID)
if targetNode, ok := tg.nodes[targetID]; ok {
targetNode.InfluencedBy = tg.removeAddressFromSlice(targetNode.InfluencedBy, node.UCXLAddress)
}
}
}
if incoming, exists := tg.influencedBy[node.ID]; exists {
for _, sourceID := range incoming {
tg.influences[sourceID] = tg.removeFromSlice(tg.influences[sourceID], node.ID)
if sourceNode, ok := tg.nodes[sourceID]; ok {
sourceNode.Influences = tg.removeAddressFromSlice(sourceNode.Influences, node.UCXLAddress)
}
}
}
if decisionNodes, exists := tg.decisionToNodes[node.DecisionID]; exists {
filtered := make([]*TemporalNode, 0, len(decisionNodes))
for _, candidate := range decisionNodes {
if candidate.ID != node.ID {
filtered = append(filtered, candidate)
}
}
if len(filtered) == 0 {
delete(tg.decisionToNodes, node.DecisionID)
delete(tg.decisions, node.DecisionID)
} else {
tg.decisionToNodes[node.DecisionID] = filtered
}
}
delete(tg.nodes, node.ID)
delete(tg.influences, node.ID)
delete(tg.influencedBy, node.ID)
@@ -782,7 +852,6 @@ func (tg *temporalGraphImpl) CompactHistory(ctx context.Context, beforeTime time
}
}
// Clear caches after compaction
tg.pathCache = make(map[string][]*DecisionStep)
tg.metricsCache = make(map[string]interface{})
@@ -901,12 +970,62 @@ func (tg *temporalGraphImpl) isInfluentialDecision(node *TemporalNode) bool {
}
func (tg *temporalGraphImpl) persistTemporalNode(ctx context.Context, node *TemporalNode) error {
// Convert to storage format and persist
// This would integrate with the storage system
// For now, we'll assume persistence happens in memory
if node == nil {
return fmt.Errorf("temporal node cannot be nil")
}
if tg.persistence != nil {
if err := tg.persistence.PersistTemporalNode(ctx, node); err != nil {
return fmt.Errorf("failed to persist temporal node: %w", err)
}
}
if tg.storage == nil || node.Context == nil {
return nil
}
roles := node.Context.EncryptedFor
if len(roles) == 0 {
roles = []string{"default"}
}
exists, err := tg.storage.ExistsContext(ctx, node.Context.UCXLAddress)
if err != nil {
return fmt.Errorf("failed to check context existence: %w", err)
}
if exists {
if err := tg.storage.UpdateContext(ctx, node.Context, roles); err != nil {
return fmt.Errorf("failed to update context for %s: %w", node.Context.UCXLAddress.String(), err)
}
return nil
}
if err := tg.storage.StoreContext(ctx, node.Context, roles); err != nil {
return fmt.Errorf("failed to store context for %s: %w", node.Context.UCXLAddress.String(), err)
}
return nil
}
func ensureString(list []string, value string) []string {
for _, existing := range list {
if existing == value {
return list
}
}
return append(list, value)
}
func ensureAddress(list []ucxl.Address, value ucxl.Address) []ucxl.Address {
for _, existing := range list {
if existing.String() == value.String() {
return list
}
}
return append(list, value)
}
func contains(s, substr string) bool {
return len(s) >= len(substr) && (s == substr ||
(len(s) > len(substr) && (s[:len(substr)] == substr || s[len(s)-len(substr):] == substr)))

353
pkg/slurp/temporal/graph_test.go
View File

@@ -1,154 +1,46 @@
//go:build slurp_full
// +build slurp_full
package temporal
import (
"context"
"fmt"
"testing"
"time"
"chorus/pkg/ucxl"
slurpContext "chorus/pkg/slurp/context"
"chorus/pkg/slurp/storage"
"chorus/pkg/ucxl"
)
// Mock storage for testing
type mockStorage struct {
data map[string]interface{}
}
func newMockStorage() *mockStorage {
return &mockStorage{
data: make(map[string]interface{}),
}
}
func (ms *mockStorage) StoreContext(ctx context.Context, node *slurpContext.ContextNode, roles []string) error {
ms.data[node.UCXLAddress.String()] = node
return nil
}
func (ms *mockStorage) RetrieveContext(ctx context.Context, address ucxl.Address, role string) (*slurpContext.ContextNode, error) {
if data, exists := ms.data[address.String()]; exists {
return data.(*slurpContext.ContextNode), nil
}
return nil, storage.ErrNotFound
}
func (ms *mockStorage) UpdateContext(ctx context.Context, node *slurpContext.ContextNode, roles []string) error {
ms.data[node.UCXLAddress.String()] = node
return nil
}
func (ms *mockStorage) DeleteContext(ctx context.Context, address ucxl.Address) error {
delete(ms.data, address.String())
return nil
}
func (ms *mockStorage) ExistsContext(ctx context.Context, address ucxl.Address) (bool, error) {
_, exists := ms.data[address.String()]
return exists, nil
}
func (ms *mockStorage) ListContexts(ctx context.Context, criteria *storage.ListCriteria) ([]*slurpContext.ContextNode, error) {
results := make([]*slurpContext.ContextNode, 0)
for _, data := range ms.data {
if node, ok := data.(*slurpContext.ContextNode); ok {
results = append(results, node)
}
}
return results, nil
}
func (ms *mockStorage) SearchContexts(ctx context.Context, query *storage.SearchQuery) (*storage.SearchResults, error) {
return &storage.SearchResults{}, nil
}
func (ms *mockStorage) BatchStore(ctx context.Context, batch *storage.BatchStoreRequest) (*storage.BatchStoreResult, error) {
return &storage.BatchStoreResult{}, nil
}
func (ms *mockStorage) BatchRetrieve(ctx context.Context, batch *storage.BatchRetrieveRequest) (*storage.BatchRetrieveResult, error) {
return &storage.BatchRetrieveResult{}, nil
}
func (ms *mockStorage) GetStorageStats(ctx context.Context) (*storage.StorageStatistics, error) {
return &storage.StorageStatistics{}, nil
}
func (ms *mockStorage) Sync(ctx context.Context) error {
return nil
}
func (ms *mockStorage) Backup(ctx context.Context, destination string) error {
return nil
}
func (ms *mockStorage) Restore(ctx context.Context, source string) error {
return nil
}
// Test helpers
func createTestAddress(path string) ucxl.Address {
addr, _ := ucxl.ParseAddress(fmt.Sprintf("ucxl://test/%s", path))
return *addr
}
func createTestContext(path string, technologies []string) *slurpContext.ContextNode {
return &slurpContext.ContextNode{
Path: path,
UCXLAddress: createTestAddress(path),
Summary: fmt.Sprintf("Test context for %s", path),
Purpose: fmt.Sprintf("Test purpose for %s", path),
Technologies: technologies,
Tags: []string{"test"},
Insights: []string{"test insight"},
GeneratedAt: time.Now(),
RAGConfidence: 0.8,
}
}
func createTestDecision(id, maker, rationale string, scope ImpactScope) *DecisionMetadata {
return &DecisionMetadata{
ID: id,
Maker: maker,
Rationale: rationale,
Scope: scope,
ConfidenceLevel: 0.8,
ExternalRefs: []string{},
CreatedAt: time.Now(),
ImplementationStatus: "complete",
Metadata: make(map[string]interface{}),
}
}
// Core temporal graph tests
func TestTemporalGraph_CreateInitialContext(t *testing.T) {
storage := newMockStorage()
graph := NewTemporalGraph(storage)
graph := NewTemporalGraph(storage).(*temporalGraphImpl)
ctx := context.Background()
address := createTestAddress("test/component")
contextData := createTestContext("test/component", []string{"go", "test"})
node, err := graph.CreateInitialContext(ctx, address, contextData, "test_creator")
if err != nil {
t.Fatalf("Failed to create initial context: %v", err)
}
if node == nil {
t.Fatal("Expected node to be created")
}
if node.Version != 1 {
t.Errorf("Expected version 1, got %d", node.Version)
}
if node.ChangeReason != ReasonInitialCreation {
t.Errorf("Expected initial creation reason, got %s", node.ChangeReason)
}
if node.ParentNode != nil {
t.Error("Expected no parent node for initial context")
}
@@ -158,34 +50,34 @@ func TestTemporalGraph_EvolveContext(t *testing.T) {
storage := newMockStorage()
graph := NewTemporalGraph(storage)
ctx := context.Background()
address := createTestAddress("test/component")
initialContext := createTestContext("test/component", []string{"go", "test"})
// Create initial context
_, err := graph.CreateInitialContext(ctx, address, initialContext, "test_creator")
if err != nil {
t.Fatalf("Failed to create initial context: %v", err)
}
// Evolve context
updatedContext := createTestContext("test/component", []string{"go", "test", "updated"})
decision := createTestDecision("dec-001", "test_maker", "Adding new technology", ImpactModule)
evolvedNode, err := graph.EvolveContext(ctx, address, updatedContext, ReasonCodeChange, decision)
if err != nil {
t.Fatalf("Failed to evolve context: %v", err)
}
if evolvedNode.Version != 2 {
t.Errorf("Expected version 2, got %d", evolvedNode.Version)
}
if evolvedNode.ChangeReason != ReasonCodeChange {
t.Errorf("Expected code change reason, got %s", evolvedNode.ChangeReason)
}
if evolvedNode.ParentNode == nil {
t.Error("Expected parent node reference")
}
@@ -195,33 +87,33 @@ func TestTemporalGraph_GetLatestVersion(t *testing.T) {
storage := newMockStorage()
graph := NewTemporalGraph(storage)
ctx := context.Background()
address := createTestAddress("test/component")
initialContext := createTestContext("test/component", []string{"go"})
// Create initial version
_, err := graph.CreateInitialContext(ctx, address, initialContext, "test_creator")
if err != nil {
t.Fatalf("Failed to create initial context: %v", err)
}
// Evolve multiple times
for i := 2; i <= 5; i++ {
updatedContext := createTestContext("test/component", []string{"go", fmt.Sprintf("tech%d", i)})
decision := createTestDecision(fmt.Sprintf("dec-%03d", i), "test_maker", "Update", ImpactLocal)
_, err := graph.EvolveContext(ctx, address, updatedContext, ReasonCodeChange, decision)
if err != nil {
t.Fatalf("Failed to evolve context to version %d: %v", i, err)
}
}
// Get latest version
latest, err := graph.GetLatestVersion(ctx, address)
if err != nil {
t.Fatalf("Failed to get latest version: %v", err)
}
if latest.Version != 5 {
t.Errorf("Expected latest version 5, got %d", latest.Version)
}
@@ -231,37 +123,37 @@ func TestTemporalGraph_GetEvolutionHistory(t *testing.T) {
storage := newMockStorage()
graph := NewTemporalGraph(storage)
ctx := context.Background()
address := createTestAddress("test/component")
initialContext := createTestContext("test/component", []string{"go"})
// Create initial version
_, err := graph.CreateInitialContext(ctx, address, initialContext, "test_creator")
if err != nil {
t.Fatalf("Failed to create initial context: %v", err)
}
// Evolve multiple times
for i := 2; i <= 3; i++ {
updatedContext := createTestContext("test/component", []string{"go", fmt.Sprintf("tech%d", i)})
decision := createTestDecision(fmt.Sprintf("dec-%03d", i), "test_maker", "Update", ImpactLocal)
_, err := graph.EvolveContext(ctx, address, updatedContext, ReasonCodeChange, decision)
if err != nil {
t.Fatalf("Failed to evolve context to version %d: %v", i, err)
}
}
// Get evolution history
history, err := graph.GetEvolutionHistory(ctx, address)
if err != nil {
t.Fatalf("Failed to get evolution history: %v", err)
}
if len(history) != 3 {
t.Errorf("Expected 3 versions in history, got %d", len(history))
}
// Verify ordering
for i, node := range history {
expectedVersion := i + 1
@@ -275,58 +167,58 @@ func TestTemporalGraph_InfluenceRelationships(t *testing.T) {
storage := newMockStorage()
graph := NewTemporalGraph(storage)
ctx := context.Background()
// Create two contexts
addr1 := createTestAddress("test/component1")
addr2 := createTestAddress("test/component2")
context1 := createTestContext("test/component1", []string{"go"})
context2 := createTestContext("test/component2", []string{"go"})
_, err := graph.CreateInitialContext(ctx, addr1, context1, "test_creator")
if err != nil {
t.Fatalf("Failed to create context 1: %v", err)
}
_, err = graph.CreateInitialContext(ctx, addr2, context2, "test_creator")
if err != nil {
t.Fatalf("Failed to create context 2: %v", err)
}
// Add influence relationship
err = graph.AddInfluenceRelationship(ctx, addr1, addr2)
if err != nil {
t.Fatalf("Failed to add influence relationship: %v", err)
}
// Get influence relationships
influences, influencedBy, err := graph.GetInfluenceRelationships(ctx, addr1)
if err != nil {
t.Fatalf("Failed to get influence relationships: %v", err)
}
if len(influences) != 1 {
t.Errorf("Expected 1 influence, got %d", len(influences))
}
if influences[0].String() != addr2.String() {
t.Errorf("Expected influence to addr2, got %s", influences[0].String())
}
if len(influencedBy) != 0 {
t.Errorf("Expected 0 influenced by, got %d", len(influencedBy))
}
// Check reverse relationship
influences2, influencedBy2, err := graph.GetInfluenceRelationships(ctx, addr2)
if err != nil {
t.Fatalf("Failed to get influence relationships for addr2: %v", err)
}
if len(influences2) != 0 {
t.Errorf("Expected 0 influences for addr2, got %d", len(influences2))
}
if len(influencedBy2) != 1 {
t.Errorf("Expected 1 influenced by for addr2, got %d", len(influencedBy2))
}
@@ -336,19 +228,19 @@ func TestTemporalGraph_FindRelatedDecisions(t *testing.T) {
storage := newMockStorage()
graph := NewTemporalGraph(storage)
ctx := context.Background()
// Create a network of contexts
addresses := make([]ucxl.Address, 5)
for i := 0; i < 5; i++ {
addresses[i] = createTestAddress(fmt.Sprintf("test/component%d", i))
context := createTestContext(fmt.Sprintf("test/component%d", i), []string{"go"})
_, err := graph.CreateInitialContext(ctx, addresses[i], context, "test_creator")
if err != nil {
t.Fatalf("Failed to create context %d: %v", i, err)
}
}
// Create influence chain: 0 -> 1 -> 2 -> 3 -> 4
for i := 0; i < 4; i++ {
err := graph.AddInfluenceRelationship(ctx, addresses[i], addresses[i+1])
@@ -356,24 +248,24 @@ func TestTemporalGraph_FindRelatedDecisions(t *testing.T) {
t.Fatalf("Failed to add influence relationship %d->%d: %v", i, i+1, err)
}
}
// Find related decisions within 3 hops from address 0
relatedPaths, err := graph.FindRelatedDecisions(ctx, addresses[0], 3)
if err != nil {
t.Fatalf("Failed to find related decisions: %v", err)
}
// Should find addresses 1, 2, 3 (within 3 hops)
if len(relatedPaths) < 3 {
t.Errorf("Expected at least 3 related decisions, got %d", len(relatedPaths))
}
// Verify hop distances
foundAddresses := make(map[string]int)
for _, path := range relatedPaths {
foundAddresses[path.To.String()] = path.TotalHops
}
for i := 1; i <= 3; i++ {
expectedAddr := addresses[i].String()
if hops, found := foundAddresses[expectedAddr]; found {
@@ -390,53 +282,53 @@ func TestTemporalGraph_FindDecisionPath(t *testing.T) {
storage := newMockStorage()
graph := NewTemporalGraph(storage)
ctx := context.Background()
// Create contexts
addr1 := createTestAddress("test/start")
addr2 := createTestAddress("test/middle")
addr3 := createTestAddress("test/end")
contexts := []*slurpContext.ContextNode{
createTestContext("test/start", []string{"go"}),
createTestContext("test/middle", []string{"go"}),
createTestContext("test/end", []string{"go"}),
}
addresses := []ucxl.Address{addr1, addr2, addr3}
for i, context := range contexts {
_, err := graph.CreateInitialContext(ctx, addresses[i], context, "test_creator")
if err != nil {
t.Fatalf("Failed to create context %d: %v", i, err)
}
}
// Create path: start -> middle -> end
err := graph.AddInfluenceRelationship(ctx, addr1, addr2)
if err != nil {
t.Fatalf("Failed to add relationship start->middle: %v", err)
}
err = graph.AddInfluenceRelationship(ctx, addr2, addr3)
if err != nil {
t.Fatalf("Failed to add relationship middle->end: %v", err)
}
// Find path from start to end
path, err := graph.FindDecisionPath(ctx, addr1, addr3)
if err != nil {
t.Fatalf("Failed to find decision path: %v", err)
}
if len(path) != 2 {
t.Errorf("Expected path length 2, got %d", len(path))
}
// Verify path steps
if path[0].Address.String() != addr1.String() {
t.Errorf("Expected first step to be start address, got %s", path[0].Address.String())
}
if path[1].Address.String() != addr2.String() {
t.Errorf("Expected second step to be middle address, got %s", path[1].Address.String())
}
@@ -446,29 +338,29 @@ func TestTemporalGraph_ValidateIntegrity(t *testing.T) {
storage := newMockStorage()
graph := NewTemporalGraph(storage)
ctx := context.Background()
// Create valid contexts with proper relationships
addr1 := createTestAddress("test/component1")
addr2 := createTestAddress("test/component2")
context1 := createTestContext("test/component1", []string{"go"})
context2 := createTestContext("test/component2", []string{"go"})
_, err := graph.CreateInitialContext(ctx, addr1, context1, "test_creator")
if err != nil {
t.Fatalf("Failed to create context 1: %v", err)
}
_, err = graph.CreateInitialContext(ctx, addr2, context2, "test_creator")
if err != nil {
t.Fatalf("Failed to create context 2: %v", err)
}
err = graph.AddInfluenceRelationship(ctx, addr1, addr2)
if err != nil {
t.Fatalf("Failed to add influence relationship: %v", err)
}
// Validate integrity - should pass
err = graph.ValidateTemporalIntegrity(ctx)
if err != nil {
@@ -478,68 +370,75 @@ func TestTemporalGraph_ValidateIntegrity(t *testing.T) {
func TestTemporalGraph_CompactHistory(t *testing.T) {
storage := newMockStorage()
graph := NewTemporalGraph(storage)
graphBase := NewTemporalGraph(storage)
graph := graphBase.(*temporalGraphImpl)
ctx := context.Background()
address := createTestAddress("test/component")
initialContext := createTestContext("test/component", []string{"go"})
// Create initial version (old)
oldTime := time.Now().Add(-60 * 24 * time.Hour) // 60 days ago
_, err := graph.CreateInitialContext(ctx, address, initialContext, "test_creator")
if err != nil {
t.Fatalf("Failed to create initial context: %v", err)
}
// Create several more versions
for i := 2; i <= 10; i++ {
updatedContext := createTestContext("test/component", []string{"go", fmt.Sprintf("tech%d", i)})
var reason ChangeReason
if i%3 == 0 {
reason = ReasonArchitectureChange // Major change - should be kept
} else {
reason = ReasonCodeChange // Minor change - may be compacted
}
decision := createTestDecision(fmt.Sprintf("dec-%03d", i), "test_maker", "Update", ImpactLocal)
_, err := graph.EvolveContext(ctx, address, updatedContext, reason, decision)
if err != nil {
t.Fatalf("Failed to evolve context to version %d: %v", i, err)
}
}
// Mark older versions beyond the retention window
for _, node := range graph.addressToNodes[address.String()] {
if node.Version <= 6 {
node.Timestamp = time.Now().Add(-60 * 24 * time.Hour)
}
}
// Get history before compaction
historyBefore, err := graph.GetEvolutionHistory(ctx, address)
if err != nil {
t.Fatalf("Failed to get history before compaction: %v", err)
}
// Compact history (keep recent changes within 30 days)
cutoffTime := time.Now().Add(-30 * 24 * time.Hour)
err = graph.CompactHistory(ctx, cutoffTime)
if err != nil {
t.Fatalf("Failed to compact history: %v", err)
}
// Get history after compaction
historyAfter, err := graph.GetEvolutionHistory(ctx, address)
if err != nil {
t.Fatalf("Failed to get history after compaction: %v", err)
}
// History should be smaller but still contain recent changes
if len(historyAfter) >= len(historyBefore) {
t.Errorf("Expected history to be compacted, before: %d, after: %d", len(historyBefore), len(historyAfter))
}
// Latest version should still exist
latest, err := graph.GetLatestVersion(ctx, address)
if err != nil {
t.Fatalf("Failed to get latest version after compaction: %v", err)
}
if latest.Version != 10 {
t.Errorf("Expected latest version 10 after compaction, got %d", latest.Version)
}
@@ -551,13 +450,13 @@ func BenchmarkTemporalGraph_CreateInitialContext(b *testing.B) {
storage := newMockStorage()
graph := NewTemporalGraph(storage)
ctx := context.Background()
b.ResetTimer()
for i := 0; i < b.N; i++ {
address := createTestAddress(fmt.Sprintf("test/component%d", i))
contextData := createTestContext(fmt.Sprintf("test/component%d", i), []string{"go", "test"})
_, err := graph.CreateInitialContext(ctx, address, contextData, "test_creator")
if err != nil {
b.Fatalf("Failed to create initial context: %v", err)
@@ -569,22 +468,22 @@ func BenchmarkTemporalGraph_EvolveContext(b *testing.B) {
storage := newMockStorage()
graph := NewTemporalGraph(storage)
ctx := context.Background()
// Setup: create initial context
address := createTestAddress("test/component")
initialContext := createTestContext("test/component", []string{"go"})
_, err := graph.CreateInitialContext(ctx, address, initialContext, "test_creator")
if err != nil {
b.Fatalf("Failed to create initial context: %v", err)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
updatedContext := createTestContext("test/component", []string{"go", fmt.Sprintf("tech%d", i)})
decision := createTestDecision(fmt.Sprintf("dec-%03d", i), "test_maker", "Update", ImpactLocal)
_, err := graph.EvolveContext(ctx, address, updatedContext, ReasonCodeChange, decision)
if err != nil {
b.Fatalf("Failed to evolve context: %v", err)
@@ -596,18 +495,18 @@ func BenchmarkTemporalGraph_FindRelatedDecisions(b *testing.B) {
storage := newMockStorage()
graph := NewTemporalGraph(storage)
ctx := context.Background()
// Setup: create network of 100 contexts
addresses := make([]ucxl.Address, 100)
for i := 0; i < 100; i++ {
addresses[i] = createTestAddress(fmt.Sprintf("test/component%d", i))
context := createTestContext(fmt.Sprintf("test/component%d", i), []string{"go"})
_, err := graph.CreateInitialContext(ctx, addresses[i], context, "test_creator")
if err != nil {
b.Fatalf("Failed to create context %d: %v", i, err)
}
// Add some influence relationships
if i > 0 {
err = graph.AddInfluenceRelationship(ctx, addresses[i-1], addresses[i])
@@ -615,7 +514,7 @@ func BenchmarkTemporalGraph_FindRelatedDecisions(b *testing.B) {
b.Fatalf("Failed to add influence relationship: %v", err)
}
}
// Add some random relationships
if i > 10 && i%10 == 0 {
err = graph.AddInfluenceRelationship(ctx, addresses[i-10], addresses[i])
@@ -624,9 +523,9 @@ func BenchmarkTemporalGraph_FindRelatedDecisions(b *testing.B) {
}
}
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
startIdx := i % 50 // Use first 50 as starting points
_, err := graph.FindRelatedDecisions(ctx, addresses[startIdx], 5)
@@ -642,22 +541,22 @@ func TestTemporalGraphIntegration_ComplexScenario(t *testing.T) {
storage := newMockStorage()
graph := NewTemporalGraph(storage)
ctx := context.Background()
// Scenario: Microservices architecture evolution
services := []string{"user-service", "order-service", "payment-service", "notification-service"}
addresses := make([]ucxl.Address, len(services))
// Create initial services
for i, service := range services {
addresses[i] = createTestAddress(fmt.Sprintf("microservices/%s", service))
context := createTestContext(fmt.Sprintf("microservices/%s", service), []string{"go", "microservice"})
_, err := graph.CreateInitialContext(ctx, addresses[i], context, "architect")
if err != nil {
t.Fatalf("Failed to create %s: %v", service, err)
}
}
// Establish service dependencies
// user-service -> order-service -> payment-service
// order-service -> notification-service
@@ -666,38 +565,38 @@ func TestTemporalGraphIntegration_ComplexScenario(t *testing.T) {
{1, 2}, // order -> payment
{1, 3}, // order -> notification
}
for _, dep := range dependencies {
err := graph.AddInfluenceRelationship(ctx, addresses[dep[0]], addresses[dep[1]])
if err != nil {
t.Fatalf("Failed to add dependency: %v", err)
}
}
// Evolve payment service (add security features)
paymentContext := createTestContext("microservices/payment-service", []string{"go", "microservice", "security", "encryption"})
decision := createTestDecision("sec-001", "security-team", "Add encryption for PCI compliance", ImpactProject)
_, err := graph.EvolveContext(ctx, addresses[2], paymentContext, ReasonSecurityReview, decision)
if err != nil {
t.Fatalf("Failed to evolve payment service: %v", err)
}
// Evolve order service (performance improvements)
orderContext := createTestContext("microservices/order-service", []string{"go", "microservice", "caching", "performance"})
decision2 := createTestDecision("perf-001", "performance-team", "Add Redis caching", ImpactModule)
_, err = graph.EvolveContext(ctx, addresses[1], orderContext, ReasonPerformanceInsight, decision2)
if err != nil {
t.Fatalf("Failed to evolve order service: %v", err)
}
// Test: Find impact of payment service changes
relatedPaths, err := graph.FindRelatedDecisions(ctx, addresses[2], 3)
if err != nil {
t.Fatalf("Failed to find related decisions: %v", err)
}
// Should find order-service as it depends on payment-service
foundOrderService := false
for _, path := range relatedPaths {
@@ -706,21 +605,21 @@ func TestTemporalGraphIntegration_ComplexScenario(t *testing.T) {
break
}
}
if !foundOrderService {
t.Error("Expected to find order-service in related decisions")
}
// Test: Get evolution history for order service
history, err := graph.GetEvolutionHistory(ctx, addresses[1])
if err != nil {
t.Fatalf("Failed to get order service history: %v", err)
}
if len(history) != 2 {
t.Errorf("Expected 2 versions in order service history, got %d", len(history))
}
// Test: Validate overall integrity
err = graph.ValidateTemporalIntegrity(ctx)
if err != nil {
@@ -734,35 +633,35 @@ func TestTemporalGraph_ErrorHandling(t *testing.T) {
storage := newMockStorage()
graph := NewTemporalGraph(storage)
ctx := context.Background()
// Test: Get latest version for non-existent address
nonExistentAddr := createTestAddress("non/existent")
_, err := graph.GetLatestVersion(ctx, nonExistentAddr)
if err == nil {
t.Error("Expected error when getting latest version for non-existent address")
}
// Test: Evolve non-existent context
context := createTestContext("non/existent", []string{"go"})
decision := createTestDecision("dec-001", "test", "Test", ImpactLocal)
_, err = graph.EvolveContext(ctx, nonExistentAddr, context, ReasonCodeChange, decision)
if err == nil {
t.Error("Expected error when evolving non-existent context")
}
// Test: Add influence relationship with non-existent addresses
addr1 := createTestAddress("test/addr1")
addr2 := createTestAddress("test/addr2")
err = graph.AddInfluenceRelationship(ctx, addr1, addr2)
if err == nil {
t.Error("Expected error when adding influence relationship with non-existent addresses")
}
// Test: Find decision path between non-existent addresses
_, err = graph.FindDecisionPath(ctx, addr1, addr2)
if err == nil {
t.Error("Expected error when finding path between non-existent addresses")
}
}
}

6
pkg/slurp/temporal/influence_analyzer.go
View File

@@ -899,14 +899,15 @@ func (ia *influenceAnalyzerImpl) findShortestPathLength(fromID, toID string) int
func (ia *influenceAnalyzerImpl) getNodeCentrality(nodeID string) float64 {
// Simple centrality based on degree
influencedBy := len(ia.graph.influencedBy[nodeID])
outgoing := len(ia.graph.influences[nodeID])
incoming := len(ia.graph.influencedBy[nodeID])
totalNodes := len(ia.graph.nodes)
if totalNodes <= 1 {
return 0
}
return float64(influences+influencedBy) / float64(totalNodes-1)
return float64(outgoing+incoming) / float64(totalNodes-1)
}
func (ia *influenceAnalyzerImpl) calculateNodeDegreeCentrality(nodeID string) float64 {
@@ -968,7 +969,6 @@ func (ia *influenceAnalyzerImpl) calculateNodeClosenessCentrality(nodeID string)
func (ia *influenceAnalyzerImpl) calculateNodePageRank(nodeID string) float64 {
// This is already calculated in calculatePageRank, so we'll use a simple approximation
influences := len(ia.graph.influences[nodeID])
influencedBy := len(ia.graph.influencedBy[nodeID])
// Simple approximation based on in-degree with damping

198
pkg/slurp/temporal/influence_analyzer_test.go
View File

@@ -1,12 +1,16 @@
//go:build slurp_full
// +build slurp_full
package temporal
import (
"context"
"fmt"
"testing"
"time"
"chorus/pkg/ucxl"
slurpContext "chorus/pkg/slurp/context"
"chorus/pkg/ucxl"
)
func TestInfluenceAnalyzer_AnalyzeInfluenceNetwork(t *testing.T) {
@@ -14,57 +18,57 @@ func TestInfluenceAnalyzer_AnalyzeInfluenceNetwork(t *testing.T) {
graph := NewTemporalGraph(storage).(*temporalGraphImpl)
analyzer := NewInfluenceAnalyzer(graph)
ctx := context.Background()
// Create a network of 5 contexts
addresses := make([]ucxl.Address, 5)
for i := 0; i < 5; i++ {
addresses[i] = createTestAddress(fmt.Sprintf("test/component%d", i))
context := createTestContext(fmt.Sprintf("test/component%d", i), []string{"go"})
_, err := graph.CreateInitialContext(ctx, addresses[i], context, "test_creator")
if err != nil {
t.Fatalf("Failed to create context %d: %v", i, err)
}
}
// Create influence relationships
// 0 -> 1, 0 -> 2, 1 -> 3, 2 -> 3, 3 -> 4
relationships := [][]int{
{0, 1}, {0, 2}, {1, 3}, {2, 3}, {3, 4},
}
for _, rel := range relationships {
err := graph.AddInfluenceRelationship(ctx, addresses[rel[0]], addresses[rel[1]])
if err != nil {
t.Fatalf("Failed to add relationship %d->%d: %v", rel[0], rel[1], err)
}
}
// Analyze influence network
analysis, err := analyzer.AnalyzeInfluenceNetwork(ctx)
if err != nil {
t.Fatalf("Failed to analyze influence network: %v", err)
}
if analysis.TotalNodes != 5 {
t.Errorf("Expected 5 total nodes, got %d", analysis.TotalNodes)
}
if analysis.TotalEdges != 5 {
t.Errorf("Expected 5 total edges, got %d", analysis.TotalEdges)
}
// Network density should be calculated correctly
// Density = edges / (nodes * (nodes-1)) = 5 / (5 * 4) = 0.25
expectedDensity := 5.0 / (5.0 * 4.0)
if abs(analysis.NetworkDensity-expectedDensity) > 0.01 {
t.Errorf("Expected network density %.2f, got %.2f", expectedDensity, analysis.NetworkDensity)
}
if analysis.CentralNodes == nil {
t.Error("Expected central nodes to be identified")
}
if analysis.AnalyzedAt.IsZero() {
t.Error("Expected analyzed timestamp to be set")
}
@@ -75,63 +79,63 @@ func TestInfluenceAnalyzer_GetInfluenceStrength(t *testing.T) {
graph := NewTemporalGraph(storage).(*temporalGraphImpl)
analyzer := NewInfluenceAnalyzer(graph)
ctx := context.Background()
// Create two contexts
addr1 := createTestAddress("test/influencer")
addr2 := createTestAddress("test/influenced")
context1 := createTestContext("test/influencer", []string{"go", "core"})
context1.RAGConfidence = 0.9 // High confidence
context2 := createTestContext("test/influenced", []string{"go", "feature"})
node1, err := graph.CreateInitialContext(ctx, addr1, context1, "test_creator")
if err != nil {
t.Fatalf("Failed to create influencer context: %v", err)
}
_, err = graph.CreateInitialContext(ctx, addr2, context2, "test_creator")
if err != nil {
t.Fatalf("Failed to create influenced context: %v", err)
}
// Set impact scope for higher influence
node1.ImpactScope = ImpactProject
// Add influence relationship
err = graph.AddInfluenceRelationship(ctx, addr1, addr2)
if err != nil {
t.Fatalf("Failed to add influence relationship: %v", err)
}
// Calculate influence strength
strength, err := analyzer.GetInfluenceStrength(ctx, addr1, addr2)
if err != nil {
t.Fatalf("Failed to get influence strength: %v", err)
}
if strength <= 0 {
t.Error("Expected positive influence strength")
}
if strength > 1 {
t.Error("Influence strength should not exceed 1")
}
// Test non-existent relationship
addr3 := createTestAddress("test/unrelated")
context3 := createTestContext("test/unrelated", []string{"go"})
_, err = graph.CreateInitialContext(ctx, addr3, context3, "test_creator")
if err != nil {
t.Fatalf("Failed to create unrelated context: %v", err)
}
strength2, err := analyzer.GetInfluenceStrength(ctx, addr1, addr3)
if err != nil {
t.Fatalf("Failed to get influence strength for unrelated: %v", err)
}
if strength2 != 0 {
t.Errorf("Expected 0 influence strength for unrelated contexts, got %f", strength2)
}
@@ -142,24 +146,24 @@ func TestInfluenceAnalyzer_FindInfluentialDecisions(t *testing.T) {
graph := NewTemporalGraph(storage).(*temporalGraphImpl)
analyzer := NewInfluenceAnalyzer(graph)
ctx := context.Background()
// Create contexts with varying influence levels
addresses := make([]ucxl.Address, 4)
contexts := make([]*slurpContext.ContextNode, 4)
for i := 0; i < 4; i++ {
addresses[i] = createTestAddress(fmt.Sprintf("test/component%d", i))
contexts[i] = createTestContext(fmt.Sprintf("test/component%d", i), []string{"go"})
// Vary confidence levels
contexts[i].RAGConfidence = 0.6 + float64(i)*0.1
_, err := graph.CreateInitialContext(ctx, addresses[i], contexts[i], "test_creator")
if err != nil {
t.Fatalf("Failed to create context %d: %v", i, err)
}
}
// Create influence network with component 1 as most influential
// 1 -> 0, 1 -> 2, 1 -> 3 (component 1 influences all others)
for i := 0; i < 4; i++ {
@@ -170,41 +174,41 @@ func TestInfluenceAnalyzer_FindInfluentialDecisions(t *testing.T) {
}
}
}
// Also add 0 -> 2 (component 0 influences component 2)
err := graph.AddInfluenceRelationship(ctx, addresses[0], addresses[2])
if err != nil {
t.Fatalf("Failed to add influence from 0 to 2: %v", err)
}
// Find influential decisions
influential, err := analyzer.FindInfluentialDecisions(ctx, 3)
if err != nil {
t.Fatalf("Failed to find influential decisions: %v", err)
}
if len(influential) == 0 {
t.Fatal("Expected to find influential decisions")
}
// Results should be sorted by influence score (highest first)
for i := 1; i < len(influential); i++ {
if influential[i-1].InfluenceScore < influential[i].InfluenceScore {
t.Error("Results should be sorted by influence score in descending order")
}
}
// Component 1 should be most influential (influences 3 others)
mostInfluential := influential[0]
if mostInfluential.Address.String() != addresses[1].String() {
t.Errorf("Expected component 1 to be most influential, got %s", mostInfluential.Address.String())
}
// Check that influence reasons are provided
if len(mostInfluential.InfluenceReasons) == 0 {
t.Error("Expected influence reasons to be provided")
}
// Check that impact analysis is provided
if mostInfluential.ImpactAnalysis == nil {
t.Error("Expected impact analysis to be provided")
@@ -216,72 +220,72 @@ func TestInfluenceAnalyzer_AnalyzeDecisionImpact(t *testing.T) {
graph := NewTemporalGraph(storage).(*temporalGraphImpl)
analyzer := NewInfluenceAnalyzer(graph)
ctx := context.Background()
// Create a context and evolve it
address := createTestAddress("test/core-service")
initialContext := createTestContext("test/core-service", []string{"go", "core"})
_, err := graph.CreateInitialContext(ctx, address, initialContext, "test_creator")
if err != nil {
t.Fatalf("Failed to create initial context: %v", err)
}
// Create dependent contexts
dependentAddrs := make([]ucxl.Address, 3)
for i := 0; i < 3; i++ {
dependentAddrs[i] = createTestAddress(fmt.Sprintf("test/dependent%d", i))
dependentContext := createTestContext(fmt.Sprintf("test/dependent%d", i), []string{"go"})
_, err := graph.CreateInitialContext(ctx, dependentAddrs[i], dependentContext, "test_creator")
if err != nil {
t.Fatalf("Failed to create dependent context %d: %v", i, err)
}
// Add influence relationship
err = graph.AddInfluenceRelationship(ctx, address, dependentAddrs[i])
if err != nil {
t.Fatalf("Failed to add influence to dependent %d: %v", i, err)
}
}
// Evolve the core service with an architectural change
updatedContext := createTestContext("test/core-service", []string{"go", "core", "microservice"})
decision := createTestDecision("arch-001", "architect", "Split into microservices", ImpactSystem)
evolvedNode, err := graph.EvolveContext(ctx, address, updatedContext, ReasonArchitectureChange, decision)
if err != nil {
t.Fatalf("Failed to evolve core service: %v", err)
}
// Analyze decision impact
impact, err := analyzer.AnalyzeDecisionImpact(ctx, address, evolvedNode.Version)
if err != nil {
t.Fatalf("Failed to analyze decision impact: %v", err)
}
if impact.Address.String() != address.String() {
t.Errorf("Expected impact address %s, got %s", address.String(), impact.Address.String())
}
if impact.DecisionHop != evolvedNode.Version {
t.Errorf("Expected decision hop %d, got %d", evolvedNode.Version, impact.DecisionHop)
}
// Should have direct impact on dependent services
if len(impact.DirectImpact) != 3 {
t.Errorf("Expected 3 direct impacts, got %d", len(impact.DirectImpact))
}
// Impact strength should be positive
if impact.ImpactStrength <= 0 {
t.Error("Expected positive impact strength")
}
// Should have impact categories
if len(impact.ImpactCategories) == 0 {
t.Error("Expected impact categories to be identified")
}
// Should have mitigation actions
if len(impact.MitigationActions) == 0 {
t.Error("Expected mitigation actions to be suggested")
@@ -293,37 +297,36 @@ func TestInfluenceAnalyzer_PredictInfluence(t *testing.T) {
graph := NewTemporalGraph(storage).(*temporalGraphImpl)
analyzer := NewInfluenceAnalyzer(graph)
ctx := context.Background()
// Create contexts with similar technologies
addr1 := createTestAddress("test/service1")
addr2 := createTestAddress("test/service2")
addr3 := createTestAddress("test/service3")
// Services 1 and 2 share technologies (higher prediction probability)
context1 := createTestContext("test/service1", []string{"go", "grpc", "postgres"})
context2 := createTestContext("test/service2", []string{"go", "grpc", "redis"})
context3 := createTestContext("test/service3", []string{"python", "flask"}) // Different tech stack
contexts := []*slurpContext.ContextNode{context1, context2, context3}
addresses := []ucxl.Address{addr1, addr2, addr3}
for i, context := range contexts {
_, err := graph.CreateInitialContext(ctx, addresses[i], context, "test_creator")
if err != nil {
t.Fatalf("Failed to create context %d: %v", i, err)
}
}
// Predict influence from service1
predictions, err := analyzer.PredictInfluence(ctx, addr1)
if err != nil {
t.Fatalf("Failed to predict influence: %v", err)
}
// Should predict influence to service2 (similar tech stack)
foundService2 := false
foundService3 := false
for _, prediction := range predictions {
if prediction.To.String() == addr2.String() {
foundService2 = true
@@ -332,25 +335,22 @@ func TestInfluenceAnalyzer_PredictInfluence(t *testing.T) {
t.Errorf("Expected higher prediction probability for similar service, got %f", prediction.Probability)
}
}
if prediction.To.String() == addr3.String() {
foundService3 = true
}
}
if !foundService2 && len(predictions) > 0 {
t.Error("Expected to predict influence to service with similar technology stack")
}
// Predictions should include reasons
for _, prediction := range predictions {
if len(prediction.Reasons) == 0 {
t.Error("Expected prediction reasons to be provided")
}
if prediction.Confidence <= 0 || prediction.Confidence > 1 {
t.Errorf("Expected confidence between 0 and 1, got %f", prediction.Confidence)
}
if prediction.EstimatedDelay <= 0 {
t.Error("Expected positive estimated delay")
}
@@ -362,19 +362,19 @@ func TestInfluenceAnalyzer_GetCentralityMetrics(t *testing.T) {
graph := NewTemporalGraph(storage).(*temporalGraphImpl)
analyzer := NewInfluenceAnalyzer(graph)
ctx := context.Background()
// Create a small network for centrality testing
addresses := make([]ucxl.Address, 4)
for i := 0; i < 4; i++ {
addresses[i] = createTestAddress(fmt.Sprintf("test/node%d", i))
context := createTestContext(fmt.Sprintf("test/node%d", i), []string{"go"})
_, err := graph.CreateInitialContext(ctx, addresses[i], context, "test_creator")
if err != nil {
t.Fatalf("Failed to create context %d: %v", i, err)
}
}
// Create star topology with node 0 at center
// 0 -> 1, 0 -> 2, 0 -> 3
for i := 1; i < 4; i++ {
@@ -383,29 +383,29 @@ func TestInfluenceAnalyzer_GetCentralityMetrics(t *testing.T) {
t.Fatalf("Failed to add influence 0->%d: %v", i, err)
}
}
// Calculate centrality metrics
metrics, err := analyzer.GetCentralityMetrics(ctx)
if err != nil {
t.Fatalf("Failed to get centrality metrics: %v", err)
}
if len(metrics.DegreeCentrality) != 4 {
t.Errorf("Expected degree centrality for 4 nodes, got %d", len(metrics.DegreeCentrality))
}
if len(metrics.BetweennessCentrality) != 4 {
t.Errorf("Expected betweenness centrality for 4 nodes, got %d", len(metrics.BetweennessCentrality))
}
if len(metrics.ClosenessCentrality) != 4 {
t.Errorf("Expected closeness centrality for 4 nodes, got %d", len(metrics.ClosenessCentrality))
}
if len(metrics.PageRank) != 4 {
t.Errorf("Expected PageRank for 4 nodes, got %d", len(metrics.PageRank))
}
// Node 0 should have highest degree centrality (connected to all others)
node0ID := ""
graph.mu.RLock()
@@ -418,10 +418,10 @@ func TestInfluenceAnalyzer_GetCentralityMetrics(t *testing.T) {
}
}
graph.mu.RUnlock()
if node0ID != "" {
node0Centrality := metrics.DegreeCentrality[node0ID]
// Check that other nodes have lower centrality
for nodeID, centrality := range metrics.DegreeCentrality {
if nodeID != node0ID && centrality >= node0Centrality {
@@ -429,7 +429,7 @@ func TestInfluenceAnalyzer_GetCentralityMetrics(t *testing.T) {
}
}
}
if metrics.CalculatedAt.IsZero() {
t.Error("Expected calculated timestamp to be set")
}
@@ -440,24 +440,24 @@ func TestInfluenceAnalyzer_CachingAndPerformance(t *testing.T) {
graph := NewTemporalGraph(storage).(*temporalGraphImpl)
analyzer := NewInfluenceAnalyzer(graph).(*influenceAnalyzerImpl)
ctx := context.Background()
// Create small network
addresses := make([]ucxl.Address, 3)
for i := 0; i < 3; i++ {
addresses[i] = createTestAddress(fmt.Sprintf("test/component%d", i))
context := createTestContext(fmt.Sprintf("test/component%d", i), []string{"go"})
_, err := graph.CreateInitialContext(ctx, addresses[i], context, "test_creator")
if err != nil {
t.Fatalf("Failed to create context %d: %v", i, err)
}
}
err := graph.AddInfluenceRelationship(ctx, addresses[0], addresses[1])
if err != nil {
t.Fatalf("Failed to add influence relationship: %v", err)
}
// First call should populate cache
start1 := time.Now()
analysis1, err := analyzer.AnalyzeInfluenceNetwork(ctx)
@@ -465,7 +465,7 @@ func TestInfluenceAnalyzer_CachingAndPerformance(t *testing.T) {
t.Fatalf("Failed to analyze influence network (first call): %v", err)
}
duration1 := time.Since(start1)
// Second call should use cache and be faster
start2 := time.Now()
analysis2, err := analyzer.AnalyzeInfluenceNetwork(ctx)
@@ -473,21 +473,21 @@ func TestInfluenceAnalyzer_CachingAndPerformance(t *testing.T) {
t.Fatalf("Failed to analyze influence network (second call): %v", err)
}
duration2 := time.Since(start2)
// Results should be identical
if analysis1.TotalNodes != analysis2.TotalNodes {
t.Error("Cached results should be identical to original")
}
if analysis1.TotalEdges != analysis2.TotalEdges {
t.Error("Cached results should be identical to original")
}
// Second call should be faster (cached)
// Note: In practice, this test might be flaky due to small network size
// and timing variations, but it demonstrates the caching concept
if duration2 > duration1 {
t.Logf("Warning: Second call took longer (%.2fms vs %.2fms), cache may not be working optimally",
t.Logf("Warning: Second call took longer (%.2fms vs %.2fms), cache may not be working optimally",
duration2.Seconds()*1000, duration1.Seconds()*1000)
}
}
@@ -497,18 +497,18 @@ func BenchmarkInfluenceAnalyzer_AnalyzeInfluenceNetwork(b *testing.B) {
graph := NewTemporalGraph(storage).(*temporalGraphImpl)
analyzer := NewInfluenceAnalyzer(graph)
ctx := context.Background()
// Setup: Create network of 50 contexts
addresses := make([]ucxl.Address, 50)
for i := 0; i < 50; i++ {
addresses[i] = createTestAddress(fmt.Sprintf("test/component%d", i))
context := createTestContext(fmt.Sprintf("test/component%d", i), []string{"go"})
_, err := graph.CreateInitialContext(ctx, addresses[i], context, "test_creator")
if err != nil {
b.Fatalf("Failed to create context %d: %v", i, err)
}
// Add some influence relationships
if i > 0 {
err = graph.AddInfluenceRelationship(ctx, addresses[i-1], addresses[i])
@@ -516,7 +516,7 @@ func BenchmarkInfluenceAnalyzer_AnalyzeInfluenceNetwork(b *testing.B) {
b.Fatalf("Failed to add influence relationship: %v", err)
}
}
// Add some random cross-connections
if i > 10 && i%5 == 0 {
err = graph.AddInfluenceRelationship(ctx, addresses[i-10], addresses[i])
@@ -525,9 +525,9 @@ func BenchmarkInfluenceAnalyzer_AnalyzeInfluenceNetwork(b *testing.B) {
}
}
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
_, err := analyzer.AnalyzeInfluenceNetwork(ctx)
if err != nil {
@@ -541,19 +541,19 @@ func BenchmarkInfluenceAnalyzer_GetCentralityMetrics(b *testing.B) {
graph := NewTemporalGraph(storage).(*temporalGraphImpl)
analyzer := NewInfluenceAnalyzer(graph)
ctx := context.Background()
// Setup: Create dense network
addresses := make([]ucxl.Address, 20)
for i := 0; i < 20; i++ {
addresses[i] = createTestAddress(fmt.Sprintf("test/node%d", i))
context := createTestContext(fmt.Sprintf("test/node%d", i), []string{"go"})
_, err := graph.CreateInitialContext(ctx, addresses[i], context, "test_creator")
if err != nil {
b.Fatalf("Failed to create context %d: %v", i, err)
}
}
// Create dense connections
for i := 0; i < 20; i++ {
for j := i + 1; j < 20; j++ {
@@ -565,9 +565,9 @@ func BenchmarkInfluenceAnalyzer_GetCentralityMetrics(b *testing.B) {
}
}
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
_, err := analyzer.GetCentralityMetrics(ctx)
if err != nil {
@@ -582,4 +582,4 @@ func abs(x float64) float64 {
return -x
}
return x
}
}

271
pkg/slurp/temporal/integration_test.go
View File

@@ -1,13 +1,17 @@
//go:build slurp_full
// +build slurp_full
package temporal
import (
"context"
"fmt"
"testing"
"time"
"chorus/pkg/ucxl"
slurpContext "chorus/pkg/slurp/context"
"chorus/pkg/slurp/storage"
"chorus/pkg/ucxl"
)
// Integration tests for the complete temporal graph system
@@ -16,26 +20,26 @@ func TestTemporalGraphSystem_FullIntegration(t *testing.T) {
// Create a complete temporal graph system
system := createTestSystem(t)
ctx := context.Background()
// Test scenario: E-commerce platform evolution
// Services: user-service, product-service, order-service, payment-service, notification-service
services := []string{
"user-service",
"product-service",
"product-service",
"order-service",
"payment-service",
"notification-service",
}
addresses := make([]ucxl.Address, len(services))
// Phase 1: Initial architecture setup
t.Log("Phase 1: Creating initial microservices architecture")
for i, service := range services {
addresses[i] = createTestAddress(fmt.Sprintf("ecommerce/%s", service))
initialContext := &slurpContext.ContextNode{
Path: fmt.Sprintf("ecommerce/%s", service),
UCXLAddress: addresses[i],
@@ -47,51 +51,51 @@ func TestTemporalGraphSystem_FullIntegration(t *testing.T) {
GeneratedAt: time.Now(),
RAGConfidence: 0.8,
}
_, err := system.Graph.CreateInitialContext(ctx, addresses[i], initialContext, "architect")
if err != nil {
t.Fatalf("Failed to create %s: %v", service, err)
}
}
// Phase 2: Establish service dependencies
t.Log("Phase 2: Establishing service dependencies")
dependencies := []struct {
from, to int
reason string
}{
{2, 0, "Order service needs user validation"}, // order -> user
{2, 1, "Order service needs product information"}, // order -> product
{2, 3, "Order service needs payment processing"}, // order -> payment
{2, 4, "Order service triggers notifications"}, // order -> notification
{3, 4, "Payment service sends payment confirmations"}, // payment -> notification
{2, 0, "Order service needs user validation"}, // order -> user
{2, 1, "Order service needs product information"}, // order -> product
{2, 3, "Order service needs payment processing"}, // order -> payment
{2, 4, "Order service triggers notifications"}, // order -> notification
{3, 4, "Payment service sends payment confirmations"}, // payment -> notification
}
for _, dep := range dependencies {
err := system.Graph.AddInfluenceRelationship(ctx, addresses[dep.from], addresses[dep.to])
if err != nil {
t.Fatalf("Failed to add dependency %s -> %s: %v",
t.Fatalf("Failed to add dependency %s -> %s: %v",
services[dep.from], services[dep.to], err)
}
t.Logf("Added dependency: %s -> %s (%s)",
t.Logf("Added dependency: %s -> %s (%s)",
services[dep.from], services[dep.to], dep.reason)
}
// Phase 3: System evolution - Add caching layer
t.Log("Phase 3: Adding Redis caching to improve performance")
for i, service := range []string{"user-service", "product-service"} {
addr := addresses[i]
updatedContext := &slurpContext.ContextNode{
Path: fmt.Sprintf("ecommerce/%s", service),
UCXLAddress: addr,
Summary: fmt.Sprintf("%s with Redis caching layer", service),
Purpose: fmt.Sprintf("Manage %s with improved performance", service[:len(service)-8]),
Technologies: []string{"go", "grpc", "postgres", "redis"},
Tags: []string{"microservice", "ecommerce", "cached"},
Insights: []string{
Path: fmt.Sprintf("ecommerce/%s", service),
UCXLAddress: addr,
Summary: fmt.Sprintf("%s with Redis caching layer", service),
Purpose: fmt.Sprintf("Manage %s with improved performance", service[:len(service)-8]),
Technologies: []string{"go", "grpc", "postgres", "redis"},
Tags: []string{"microservice", "ecommerce", "cached"},
Insights: []string{
fmt.Sprintf("Core service for %s management", service[:len(service)-8]),
"Improved response times with Redis caching",
"Reduced database load",
@@ -99,7 +103,7 @@ func TestTemporalGraphSystem_FullIntegration(t *testing.T) {
GeneratedAt: time.Now(),
RAGConfidence: 0.85,
}
decision := &DecisionMetadata{
ID: fmt.Sprintf("perf-cache-%d", i+1),
Maker: "performance-team",
@@ -111,26 +115,26 @@ func TestTemporalGraphSystem_FullIntegration(t *testing.T) {
ImplementationStatus: "completed",
Metadata: map[string]interface{}{"performance_improvement": "40%"},
}
_, err := system.Graph.EvolveContext(ctx, addr, updatedContext, ReasonPerformanceInsight, decision)
if err != nil {
t.Fatalf("Failed to add caching to %s: %v", service, err)
}
t.Logf("Added Redis caching to %s", service)
}
// Phase 4: Security enhancement - Payment service PCI compliance
t.Log("Phase 4: Implementing PCI compliance for payment service")
paymentAddr := addresses[3] // payment-service
securePaymentContext := &slurpContext.ContextNode{
Path: "ecommerce/payment-service",
UCXLAddress: paymentAddr,
Summary: "PCI-compliant payment service with end-to-end encryption",
Purpose: "Securely process payments with PCI DSS compliance",
Technologies: []string{"go", "grpc", "postgres", "vault", "encryption"},
Tags: []string{"microservice", "ecommerce", "secure", "pci-compliant"},
Path: "ecommerce/payment-service",
UCXLAddress: paymentAddr,
Summary: "PCI-compliant payment service with end-to-end encryption",
Purpose: "Securely process payments with PCI DSS compliance",
Technologies: []string{"go", "grpc", "postgres", "vault", "encryption"},
Tags: []string{"microservice", "ecommerce", "secure", "pci-compliant"},
Insights: []string{
"Core service for payment management",
"PCI DSS Level 1 compliant",
@@ -140,7 +144,7 @@ func TestTemporalGraphSystem_FullIntegration(t *testing.T) {
GeneratedAt: time.Now(),
RAGConfidence: 0.95,
}
securityDecision := &DecisionMetadata{
ID: "sec-pci-001",
Maker: "security-team",
@@ -155,24 +159,24 @@ func TestTemporalGraphSystem_FullIntegration(t *testing.T) {
"audit_date": time.Now().Format("2006-01-02"),
},
}
_, err := system.Graph.EvolveContext(ctx, paymentAddr, securePaymentContext, ReasonSecurityReview, securityDecision)
if err != nil {
t.Fatalf("Failed to implement PCI compliance: %v", err)
}
// Phase 5: Analyze impact and relationships
t.Log("Phase 5: Analyzing system impact and relationships")
// Test influence analysis
analysis, err := system.InfluenceAnalyzer.AnalyzeInfluenceNetwork(ctx)
if err != nil {
t.Fatalf("Failed to analyze influence network: %v", err)
}
t.Logf("Network analysis: %d nodes, %d edges, density: %.3f",
t.Logf("Network analysis: %d nodes, %d edges, density: %.3f",
analysis.TotalNodes, analysis.TotalEdges, analysis.NetworkDensity)
// Order service should be central (influences most other services)
if len(analysis.CentralNodes) > 0 {
t.Logf("Most central nodes:")
@@ -183,37 +187,37 @@ func TestTemporalGraphSystem_FullIntegration(t *testing.T) {
t.Logf(" %s (influence score: %.3f)", node.Address.String(), node.InfluenceScore)
}
}
// Test decision impact analysis
paymentEvolution, err := system.Graph.GetEvolutionHistory(ctx, paymentAddr)
if err != nil {
t.Fatalf("Failed to get payment service evolution: %v", err)
}
if len(paymentEvolution) < 2 {
t.Fatalf("Expected at least 2 versions in payment service evolution, got %d", len(paymentEvolution))
}
latestVersion := paymentEvolution[len(paymentEvolution)-1]
impact, err := system.InfluenceAnalyzer.AnalyzeDecisionImpact(ctx, paymentAddr, latestVersion.Version)
if err != nil {
t.Fatalf("Failed to analyze payment service impact: %v", err)
}
t.Logf("Payment service security impact: %d direct impacts, strength: %.3f",
t.Logf("Payment service security impact: %d direct impacts, strength: %.3f",
len(impact.DirectImpact), impact.ImpactStrength)
// Test staleness detection
staleContexts, err := system.StalenessDetector.DetectStaleContexts(ctx, 0.3)
if err != nil {
t.Fatalf("Failed to detect stale contexts: %v", err)
}
t.Logf("Found %d potentially stale contexts", len(staleContexts))
// Phase 6: Query system testing
t.Log("Phase 6: Testing decision-hop queries")
// Find all services within 2 hops of order service
orderAddr := addresses[2] // order-service
hopQuery := &HopQuery{
@@ -230,78 +234,78 @@ func TestTemporalGraphSystem_FullIntegration(t *testing.T) {
Limit: 10,
IncludeMetadata: true,
}
queryResult, err := system.QuerySystem.ExecuteHopQuery(ctx, hopQuery)
if err != nil {
t.Fatalf("Failed to execute hop query: %v", err)
}
t.Logf("Hop query found %d related decisions in %v",
t.Logf("Hop query found %d related decisions in %v",
len(queryResult.Results), queryResult.ExecutionTime)
for _, result := range queryResult.Results {
t.Logf(" %s at %d hops (relevance: %.3f)",
t.Logf(" %s at %d hops (relevance: %.3f)",
result.Address.String(), result.HopDistance, result.RelevanceScore)
}
// Test decision genealogy
genealogy, err := system.QuerySystem.AnalyzeDecisionGenealogy(ctx, paymentAddr)
if err != nil {
t.Fatalf("Failed to analyze payment service genealogy: %v", err)
}
t.Logf("Payment service genealogy: %d ancestors, %d descendants, depth: %d",
t.Logf("Payment service genealogy: %d ancestors, %d descendants, depth: %d",
len(genealogy.AllAncestors), len(genealogy.AllDescendants), genealogy.GenealogyDepth)
// Phase 7: Persistence and synchronization testing
t.Log("Phase 7: Testing persistence and synchronization")
// Test backup
err = system.PersistenceManager.BackupGraph(ctx)
if err != nil {
t.Fatalf("Failed to backup graph: %v", err)
}
// Test synchronization
syncResult, err := system.PersistenceManager.SynchronizeGraph(ctx)
if err != nil {
t.Fatalf("Failed to synchronize graph: %v", err)
}
t.Logf("Synchronization completed: %d nodes processed, %d conflicts resolved",
t.Logf("Synchronization completed: %d nodes processed, %d conflicts resolved",
syncResult.NodesProcessed, syncResult.ConflictsResolved)
// Phase 8: System validation
t.Log("Phase 8: Validating system integrity")
// Validate temporal integrity
err = system.Graph.ValidateTemporalIntegrity(ctx)
if err != nil {
t.Fatalf("Temporal integrity validation failed: %v", err)
}
// Collect metrics
metrics, err := system.MetricsCollector.CollectTemporalMetrics(ctx)
if err != nil {
t.Fatalf("Failed to collect temporal metrics: %v", err)
}
t.Logf("System metrics: %d total nodes, %d decisions, %d active contexts",
t.Logf("System metrics: %d total nodes, %d decisions, %d active contexts",
metrics.TotalNodes, metrics.TotalDecisions, metrics.ActiveContexts)
// Final verification: Check that all expected relationships exist
expectedConnections := []struct {
from, to int
}{
{2, 0}, {2, 1}, {2, 3}, {2, 4}, {3, 4}, // Dependencies we created
}
for _, conn := range expectedConnections {
influences, _, err := system.Graph.GetInfluenceRelationships(ctx, addresses[conn.from])
if err != nil {
t.Fatalf("Failed to get influence relationships: %v", err)
}
found := false
for _, influenced := range influences {
if influenced.String() == addresses[conn.to].String() {
@@ -309,35 +313,35 @@ func TestTemporalGraphSystem_FullIntegration(t *testing.T) {
break
}
}
if !found {
t.Errorf("Expected influence relationship %s -> %s not found",
t.Errorf("Expected influence relationship %s -> %s not found",
services[conn.from], services[conn.to])
}
}
t.Log("Integration test completed successfully!")
}
func TestTemporalGraphSystem_PerformanceUnderLoad(t *testing.T) {
system := createTestSystem(t)
ctx := context.Background()
t.Log("Creating large-scale system for performance testing")
// Create 100 contexts representing a complex microservices architecture
numServices := 100
addresses := make([]ucxl.Address, numServices)
// Create services in batches to simulate realistic growth
batchSize := 10
for batch := 0; batch < numServices/batchSize; batch++ {
start := batch * batchSize
end := start + batchSize
for i := start; i < end; i++ {
addresses[i] = createTestAddress(fmt.Sprintf("services/service-%03d", i))
context := &slurpContext.ContextNode{
Path: fmt.Sprintf("services/service-%03d", i),
UCXLAddress: addresses[i],
@@ -349,19 +353,19 @@ func TestTemporalGraphSystem_PerformanceUnderLoad(t *testing.T) {
GeneratedAt: time.Now(),
RAGConfidence: 0.7 + float64(i%3)*0.1,
}
_, err := system.Graph.CreateInitialContext(ctx, addresses[i], context, "automation")
if err != nil {
t.Fatalf("Failed to create service %d: %v", i, err)
}
}
t.Logf("Created batch %d (%d-%d)", batch+1, start, end-1)
}
// Create realistic dependency patterns
t.Log("Creating dependency relationships")
dependencyCount := 0
for i := 0; i < numServices; i++ {
// Each service depends on 2-5 other services
@@ -376,18 +380,18 @@ func TestTemporalGraphSystem_PerformanceUnderLoad(t *testing.T) {
}
}
}
t.Logf("Created %d dependency relationships", dependencyCount)
// Performance test: Large-scale evolution
t.Log("Testing large-scale context evolution")
startTime := time.Now()
evolutionCount := 0
for i := 0; i < 50; i++ { // Evolve 50 services
service := i * 2 % numServices // Distribute evenly
updatedContext := &slurpContext.ContextNode{
Path: fmt.Sprintf("services/service-%03d", service),
UCXLAddress: addresses[service],
@@ -399,7 +403,7 @@ func TestTemporalGraphSystem_PerformanceUnderLoad(t *testing.T) {
GeneratedAt: time.Now(),
RAGConfidence: 0.8,
}
decision := &DecisionMetadata{
ID: fmt.Sprintf("auto-update-%03d", service),
Maker: "automation",
@@ -409,7 +413,7 @@ func TestTemporalGraphSystem_PerformanceUnderLoad(t *testing.T) {
CreatedAt: time.Now(),
ImplementationStatus: "completed",
}
_, err := system.Graph.EvolveContext(ctx, addresses[service], updatedContext, ReasonPerformanceInsight, decision)
if err != nil {
t.Errorf("Failed to evolve service %d: %v", service, err)
@@ -417,33 +421,33 @@ func TestTemporalGraphSystem_PerformanceUnderLoad(t *testing.T) {
evolutionCount++
}
}
evolutionTime := time.Since(startTime)
t.Logf("Evolved %d services in %v (%.2f ops/sec)",
t.Logf("Evolved %d services in %v (%.2f ops/sec)",
evolutionCount, evolutionTime, float64(evolutionCount)/evolutionTime.Seconds())
// Performance test: Large-scale analysis
t.Log("Testing large-scale influence analysis")
analysisStart := time.Now()
analysis, err := system.InfluenceAnalyzer.AnalyzeInfluenceNetwork(ctx)
if err != nil {
t.Fatalf("Failed to analyze large network: %v", err)
}
analysisTime := time.Since(analysisStart)
t.Logf("Analyzed network (%d nodes, %d edges) in %v",
t.Logf("Analyzed network (%d nodes, %d edges) in %v",
analysis.TotalNodes, analysis.TotalEdges, analysisTime)
// Performance test: Bulk queries
t.Log("Testing bulk decision-hop queries")
queryStart := time.Now()
queryCount := 0
for i := 0; i < 20; i++ { // Test 20 queries
startService := i * 5 % numServices
hopQuery := &HopQuery{
StartAddress: addresses[startService],
MaxHops: 3,
@@ -453,7 +457,7 @@ func TestTemporalGraphSystem_PerformanceUnderLoad(t *testing.T) {
},
Limit: 50,
}
_, err := system.QuerySystem.ExecuteHopQuery(ctx, hopQuery)
if err != nil {
t.Errorf("Failed to execute query %d: %v", i, err)
@@ -461,80 +465,80 @@ func TestTemporalGraphSystem_PerformanceUnderLoad(t *testing.T) {
queryCount++
}
}
queryTime := time.Since(queryStart)
t.Logf("Executed %d queries in %v (%.2f queries/sec)",
t.Logf("Executed %d queries in %v (%.2f queries/sec)",
queryCount, queryTime, float64(queryCount)/queryTime.Seconds())
// Memory usage check
metrics, err := system.MetricsCollector.CollectTemporalMetrics(ctx)
if err != nil {
t.Fatalf("Failed to collect final metrics: %v", err)
}
t.Logf("Final system state: %d nodes, %d decisions, %d connections",
t.Logf("Final system state: %d nodes, %d decisions, %d connections",
metrics.TotalNodes, metrics.TotalDecisions, metrics.InfluenceConnections)
// Verify system integrity under load
err = system.Graph.ValidateTemporalIntegrity(ctx)
if err != nil {
t.Fatalf("System integrity compromised under load: %v", err)
}
t.Log("Performance test completed successfully!")
}
func TestTemporalGraphSystem_ErrorRecovery(t *testing.T) {
system := createTestSystem(t)
ctx := context.Background()
t.Log("Testing error recovery and resilience")
// Create some contexts
addresses := make([]ucxl.Address, 5)
for i := 0; i < 5; i++ {
addresses[i] = createTestAddress(fmt.Sprintf("test/resilience-%d", i))
context := createTestContext(fmt.Sprintf("test/resilience-%d", i), []string{"go"})
_, err := system.Graph.CreateInitialContext(ctx, addresses[i], context, "test")
if err != nil {
t.Fatalf("Failed to create context %d: %v", i, err)
}
}
// Test recovery from invalid operations
t.Log("Testing recovery from invalid operations")
// Try to evolve non-existent context
invalidAddr := createTestAddress("test/non-existent")
invalidContext := createTestContext("test/non-existent", []string{"go"})
invalidDecision := createTestDecision("invalid-001", "test", "Invalid", ImpactLocal)
_, err := system.Graph.EvolveContext(ctx, invalidAddr, invalidContext, ReasonCodeChange, invalidDecision)
if err == nil {
t.Error("Expected error when evolving non-existent context")
}
// Try to add influence to non-existent context
err = system.Graph.AddInfluenceRelationship(ctx, addresses[0], invalidAddr)
if err == nil {
t.Error("Expected error when adding influence to non-existent context")
}
// System should still be functional after errors
_, err = system.Graph.GetLatestVersion(ctx, addresses[0])
if err != nil {
t.Fatalf("System became non-functional after errors: %v", err)
}
// Test integrity validation detects and reports issues
t.Log("Testing integrity validation")
err = system.Graph.ValidateTemporalIntegrity(ctx)
if err != nil {
t.Fatalf("Integrity validation failed: %v", err)
}
t.Log("Error recovery test completed successfully!")
}
@@ -546,14 +550,14 @@ func createTestSystem(t *testing.T) *TemporalGraphSystem {
distributedStorage := &mockDistributedStorage{}
encryptedStorage := &mockEncryptedStorage{}
backupManager := &mockBackupManager{}
// Create factory with test configuration
config := DefaultTemporalConfig()
config.EnableDebugLogging = true
config.EnableValidation = true
factory := NewTemporalGraphFactory(contextStore, config)
// Create complete system
system, err := factory.CreateTemporalGraphSystem(
localStorage,
@@ -564,7 +568,7 @@ func createTestSystem(t *testing.T) *TemporalGraphSystem {
if err != nil {
t.Fatalf("Failed to create temporal graph system: %v", err)
}
return system
}
@@ -720,10 +724,9 @@ type mockBackupManager struct{}
func (m *mockBackupManager) CreateBackup(ctx context.Context, config *storage.BackupConfig) (*storage.BackupInfo, error) {
return &storage.BackupInfo{
ID: "test-backup-1",
CreatedAt: time.Now(),
Size: 1024,
Description: "Test backup",
ID: "test-backup-1",
CreatedAt: time.Now(),
Size: 1024,
}, nil
}
@@ -751,4 +754,4 @@ func (m *mockBackupManager) ScheduleBackup(ctx context.Context, schedule *storag
func (m *mockBackupManager) GetBackupStats(ctx context.Context) (*storage.BackupStatistics, error) {
return &storage.BackupStatistics{}, nil
}
}

19
pkg/slurp/temporal/navigator_impl.go
View File

@@ -62,8 +62,19 @@ func (dn *decisionNavigatorImpl) NavigateDecisionHops(ctx context.Context, addre
dn.mu.RLock()
defer dn.mu.RUnlock()
// Get starting node
startNode, err := dn.graph.getLatestNodeUnsafe(address)
// Determine starting node based on navigation direction
var (
startNode *TemporalNode
err error
)
switch direction {
case NavigationForward:
startNode, err = dn.graph.GetVersionAtDecision(ctx, address, 1)
default:
startNode, err = dn.graph.getLatestNodeUnsafe(address)
}
if err != nil {
return nil, fmt.Errorf("failed to get starting node: %w", err)
}
@@ -254,9 +265,7 @@ func (dn *decisionNavigatorImpl) ResetNavigation(ctx context.Context, address uc
// Clear any navigation sessions for this address
for _, session := range dn.navigationSessions {
if session.CurrentPosition.String() == address.String() {
// Reset to latest version
latestNode, err := dn.graph.getLatestNodeUnsafe(address)
if err != nil {
if _, err := dn.graph.getLatestNodeUnsafe(address); err != nil {
return fmt.Errorf("failed to get latest node: %w", err)
}

130
pkg/slurp/temporal/navigator_test.go
View File

@@ -1,12 +1,14 @@
//go:build slurp_full
// +build slurp_full
package temporal
import (
"context"
"fmt"
"testing"
"time"
"chorus/pkg/ucxl"
slurpContext "chorus/pkg/slurp/context"
)
func TestDecisionNavigator_NavigateDecisionHops(t *testing.T) {
@@ -14,49 +16,49 @@ func TestDecisionNavigator_NavigateDecisionHops(t *testing.T) {
graph := NewTemporalGraph(storage).(*temporalGraphImpl)
navigator := NewDecisionNavigator(graph)
ctx := context.Background()
// Create a chain of versions
address := createTestAddress("test/component")
initialContext := createTestContext("test/component", []string{"go"})
_, err := graph.CreateInitialContext(ctx, address, initialContext, "test_creator")
if err != nil {
t.Fatalf("Failed to create initial context: %v", err)
}
// Create 3 more versions
for i := 2; i <= 4; i++ {
updatedContext := createTestContext("test/component", []string{"go", fmt.Sprintf("tech%d", i)})
decision := createTestDecision(fmt.Sprintf("dec-%03d", i), "test_maker", "Update", ImpactLocal)
_, err := graph.EvolveContext(ctx, address, updatedContext, ReasonCodeChange, decision)
if err != nil {
t.Fatalf("Failed to evolve context to version %d: %v", i, err)
}
}
// Test forward navigation from version 1
v1, err := graph.GetVersionAtDecision(ctx, address, 1)
_, err = graph.GetVersionAtDecision(ctx, address, 1)
if err != nil {
t.Fatalf("Failed to get version 1: %v", err)
}
// Navigate 2 hops forward from version 1
result, err := navigator.NavigateDecisionHops(ctx, address, 2, NavigationForward)
if err != nil {
t.Fatalf("Failed to navigate forward: %v", err)
}
if result.Version != 3 {
t.Errorf("Expected to navigate to version 3, got version %d", result.Version)
}
// Test backward navigation from version 4
result2, err := navigator.NavigateDecisionHops(ctx, address, 2, NavigationBackward)
if err != nil {
t.Fatalf("Failed to navigate backward: %v", err)
}
if result2.Version != 2 {
t.Errorf("Expected to navigate to version 2, got version %d", result2.Version)
}
@@ -67,52 +69,52 @@ func TestDecisionNavigator_GetDecisionTimeline(t *testing.T) {
graph := NewTemporalGraph(storage).(*temporalGraphImpl)
navigator := NewDecisionNavigator(graph)
ctx := context.Background()
// Create main context with evolution
address := createTestAddress("test/main")
initialContext := createTestContext("test/main", []string{"go"})
_, err := graph.CreateInitialContext(ctx, address, initialContext, "test_creator")
if err != nil {
t.Fatalf("Failed to create initial context: %v", err)
}
// Evolve main context
for i := 2; i <= 3; i++ {
updatedContext := createTestContext("test/main", []string{"go", fmt.Sprintf("feature%d", i)})
decision := createTestDecision(fmt.Sprintf("main-dec-%03d", i), fmt.Sprintf("dev%d", i), "Add feature", ImpactModule)
_, err := graph.EvolveContext(ctx, address, updatedContext, ReasonCodeChange, decision)
if err != nil {
t.Fatalf("Failed to evolve main context to version %d: %v", i, err)
}
}
// Create related context
relatedAddr := createTestAddress("test/related")
relatedContext := createTestContext("test/related", []string{"go"})
_, err = graph.CreateInitialContext(ctx, relatedAddr, relatedContext, "test_creator")
if err != nil {
t.Fatalf("Failed to create related context: %v", err)
}
// Add influence relationship
err = graph.AddInfluenceRelationship(ctx, address, relatedAddr)
if err != nil {
t.Fatalf("Failed to add influence relationship: %v", err)
}
// Get decision timeline with related decisions
timeline, err := navigator.GetDecisionTimeline(ctx, address, true, 5)
if err != nil {
t.Fatalf("Failed to get decision timeline: %v", err)
}
if len(timeline.DecisionSequence) != 3 {
t.Errorf("Expected 3 decisions in timeline, got %d", len(timeline.DecisionSequence))
}
// Check ordering
for i, entry := range timeline.DecisionSequence {
expectedVersion := i + 1
@@ -120,12 +122,12 @@ func TestDecisionNavigator_GetDecisionTimeline(t *testing.T) {
t.Errorf("Expected version %d at index %d, got %d", expectedVersion, i, entry.Version)
}
}
// Should have related decisions
if len(timeline.RelatedDecisions) == 0 {
t.Error("Expected to find related decisions")
}
if timeline.AnalysisMetadata == nil {
t.Error("Expected analysis metadata")
}
@@ -136,20 +138,20 @@ func TestDecisionNavigator_FindStaleContexts(t *testing.T) {
graph := NewTemporalGraph(storage).(*temporalGraphImpl)
navigator := NewDecisionNavigator(graph)
ctx := context.Background()
// Create contexts with different staleness levels
addresses := make([]ucxl.Address, 3)
for i := 0; i < 3; i++ {
addresses[i] = createTestAddress(fmt.Sprintf("test/component%d", i))
context := createTestContext(fmt.Sprintf("test/component%d", i), []string{"go"})
_, err := graph.CreateInitialContext(ctx, addresses[i], context, "test_creator")
if err != nil {
t.Fatalf("Failed to create context %d: %v", i, err)
}
}
// Manually set staleness scores for testing
graph.mu.Lock()
for _, nodes := range graph.addressToNodes {
@@ -159,13 +161,13 @@ func TestDecisionNavigator_FindStaleContexts(t *testing.T) {
}
}
graph.mu.Unlock()
// Find stale contexts with threshold 0.5
staleContexts, err := navigator.FindStaleContexts(ctx, 0.5)
if err != nil {
t.Fatalf("Failed to find stale contexts: %v", err)
}
// Should find contexts with staleness >= 0.5
expectedStale := 0
graph.mu.RLock()
@@ -177,11 +179,11 @@ func TestDecisionNavigator_FindStaleContexts(t *testing.T) {
}
}
graph.mu.RUnlock()
if len(staleContexts) != expectedStale {
t.Errorf("Expected %d stale contexts, got %d", expectedStale, len(staleContexts))
}
// Results should be sorted by staleness score (highest first)
for i := 1; i < len(staleContexts); i++ {
if staleContexts[i-1].StalenessScore < staleContexts[i].StalenessScore {
@@ -195,27 +197,27 @@ func TestDecisionNavigator_BookmarkManagement(t *testing.T) {
graph := NewTemporalGraph(storage).(*temporalGraphImpl)
navigator := NewDecisionNavigator(graph)
ctx := context.Background()
// Create context with multiple versions
address := createTestAddress("test/component")
initialContext := createTestContext("test/component", []string{"go"})
_, err := graph.CreateInitialContext(ctx, address, initialContext, "test_creator")
if err != nil {
t.Fatalf("Failed to create initial context: %v", err)
}
// Create more versions
for i := 2; i <= 5; i++ {
updatedContext := createTestContext("test/component", []string{"go", fmt.Sprintf("feature%d", i)})
decision := createTestDecision(fmt.Sprintf("dec-%03d", i), "test_maker", "Update", ImpactLocal)
_, err := graph.EvolveContext(ctx, address, updatedContext, ReasonCodeChange, decision)
if err != nil {
t.Fatalf("Failed to evolve context to version %d: %v", i, err)
}
}
// Create bookmarks
bookmarkNames := []string{"Initial Release", "Major Feature", "Bug Fix", "Performance Improvement"}
for i, name := range bookmarkNames {
@@ -224,32 +226,32 @@ func TestDecisionNavigator_BookmarkManagement(t *testing.T) {
t.Fatalf("Failed to create bookmark %s: %v", name, err)
}
}
// List bookmarks
bookmarks, err := navigator.ListBookmarks(ctx)
if err != nil {
t.Fatalf("Failed to list bookmarks: %v", err)
}
if len(bookmarks) != len(bookmarkNames) {
t.Errorf("Expected %d bookmarks, got %d", len(bookmarkNames), len(bookmarks))
}
// Verify bookmark details
for _, bookmark := range bookmarks {
if bookmark.Address.String() != address.String() {
t.Errorf("Expected bookmark address %s, got %s", address.String(), bookmark.Address.String())
}
if bookmark.DecisionHop < 1 || bookmark.DecisionHop > 4 {
t.Errorf("Expected decision hop between 1-4, got %d", bookmark.DecisionHop)
}
if bookmark.Metadata == nil {
t.Error("Expected bookmark metadata")
}
}
// Bookmarks should be sorted by creation time (newest first)
for i := 1; i < len(bookmarks); i++ {
if bookmarks[i-1].CreatedAt.Before(bookmarks[i].CreatedAt) {
@@ -263,35 +265,35 @@ func TestDecisionNavigator_ValidationAndErrorHandling(t *testing.T) {
graph := NewTemporalGraph(storage).(*temporalGraphImpl)
navigator := NewDecisionNavigator(graph)
ctx := context.Background()
// Test: Navigate decision hops on non-existent address
nonExistentAddr := createTestAddress("non/existent")
_, err := navigator.NavigateDecisionHops(ctx, nonExistentAddr, 1, NavigationForward)
if err == nil {
t.Error("Expected error when navigating on non-existent address")
}
// Test: Create bookmark for non-existent decision
err = navigator.BookmarkDecision(ctx, nonExistentAddr, 1, "Test Bookmark")
if err == nil {
t.Error("Expected error when bookmarking non-existent decision")
}
// Create valid context for path validation tests
address := createTestAddress("test/component")
initialContext := createTestContext("test/component", []string{"go"})
_, err = graph.CreateInitialContext(ctx, address, initialContext, "test_creator")
if err != nil {
t.Fatalf("Failed to create initial context: %v", err)
}
// Test: Validate empty decision path
err = navigator.ValidateDecisionPath(ctx, []*DecisionStep{})
if err == nil {
t.Error("Expected error when validating empty decision path")
}
// Test: Validate path with nil temporal node
invalidPath := []*DecisionStep{
{
@@ -301,12 +303,12 @@ func TestDecisionNavigator_ValidationAndErrorHandling(t *testing.T) {
Relationship: "test",
},
}
err = navigator.ValidateDecisionPath(ctx, invalidPath)
if err == nil {
t.Error("Expected error when validating path with nil temporal node")
}
// Test: Get navigation history for non-existent session
_, err = navigator.GetNavigationHistory(ctx, "non-existent-session")
if err == nil {
@@ -319,29 +321,29 @@ func BenchmarkDecisionNavigator_GetDecisionTimeline(b *testing.B) {
graph := NewTemporalGraph(storage).(*temporalGraphImpl)
navigator := NewDecisionNavigator(graph)
ctx := context.Background()
// Setup: Create context with many versions
address := createTestAddress("test/component")
initialContext := createTestContext("test/component", []string{"go"})
_, err := graph.CreateInitialContext(ctx, address, initialContext, "test_creator")
if err != nil {
b.Fatalf("Failed to create initial context: %v", err)
}
// Create 100 versions
for i := 2; i <= 100; i++ {
updatedContext := createTestContext("test/component", []string{"go", fmt.Sprintf("feature%d", i)})
decision := createTestDecision(fmt.Sprintf("dec-%03d", i), "test_maker", "Update", ImpactLocal)
_, err := graph.EvolveContext(ctx, address, updatedContext, ReasonCodeChange, decision)
if err != nil {
b.Fatalf("Failed to evolve context to version %d: %v", i, err)
}
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
_, err := navigator.GetDecisionTimeline(ctx, address, true, 10)
if err != nil {
@@ -355,33 +357,33 @@ func BenchmarkDecisionNavigator_FindStaleContexts(b *testing.B) {
graph := NewTemporalGraph(storage).(*temporalGraphImpl)
navigator := NewDecisionNavigator(graph)
ctx := context.Background()
// Setup: Create many contexts
for i := 0; i < 1000; i++ {
address := createTestAddress(fmt.Sprintf("test/component%d", i))
context := createTestContext(fmt.Sprintf("test/component%d", i), []string{"go"})
_, err := graph.CreateInitialContext(ctx, address, context, "test_creator")
if err != nil {
b.Fatalf("Failed to create context %d: %v", i, err)
}
}
// Set random staleness scores
graph.mu.Lock()
for _, nodes := range graph.addressToNodes {
for _, node := range nodes {
node.Staleness = 0.3 + (float64(node.Version)*0.1) // Varying staleness
node.Staleness = 0.3 + (float64(node.Version) * 0.1) // Varying staleness
}
}
graph.mu.Unlock()
b.ResetTimer()
for i := 0; i < b.N; i++ {
_, err := navigator.FindStaleContexts(ctx, 0.5)
if err != nil {
b.Fatalf("Failed to find stale contexts: %v", err)
}
}
}
}

140
pkg/slurp/temporal/persistence.go
View File

@@ -8,7 +8,6 @@ import (
"time"
"chorus/pkg/slurp/storage"
"chorus/pkg/ucxl"
)
// persistenceManagerImpl handles persistence and synchronization of temporal graph data
@@ -151,6 +150,8 @@ func NewPersistenceManager(
config *PersistenceConfig,
) *persistenceManagerImpl {
cfg := normalizePersistenceConfig(config)
pm := &persistenceManagerImpl{
contextStore: contextStore,
localStorage: localStorage,
@@ -158,30 +159,96 @@ func NewPersistenceManager(
encryptedStore: encryptedStore,
backupManager: backupManager,
graph: graph,
config: config,
config: cfg,
pendingChanges: make(map[string]*PendingChange),
conflictResolver: NewDefaultConflictResolver(),
batchSize: config.BatchSize,
writeBuffer: make([]*TemporalNode, 0, config.BatchSize),
flushInterval: config.FlushInterval,
batchSize: cfg.BatchSize,
writeBuffer: make([]*TemporalNode, 0, cfg.BatchSize),
flushInterval: cfg.FlushInterval,
}
if graph != nil {
graph.persistence = pm
}
// Start background processes
if config.EnableAutoSync {
if cfg.EnableAutoSync {
go pm.syncWorker()
}
if config.EnableWriteBuffer {
if cfg.EnableWriteBuffer {
go pm.flushWorker()
}
if config.EnableAutoBackup {
if cfg.EnableAutoBackup {
go pm.backupWorker()
}
return pm
}
func normalizePersistenceConfig(config *PersistenceConfig) *PersistenceConfig {
if config == nil {
return defaultPersistenceConfig()
}
cloned := *config
if cloned.BatchSize <= 0 {
cloned.BatchSize = 1
}
if cloned.FlushInterval <= 0 {
cloned.FlushInterval = 30 * time.Second
}
if cloned.SyncInterval <= 0 {
cloned.SyncInterval = 15 * time.Minute
}
if cloned.MaxSyncRetries <= 0 {
cloned.MaxSyncRetries = 3
}
if len(cloned.EncryptionRoles) == 0 {
cloned.EncryptionRoles = []string{"default"}
} else {
cloned.EncryptionRoles = append([]string(nil), cloned.EncryptionRoles...)
}
if cloned.KeyPrefix == "" {
cloned.KeyPrefix = "temporal_graph"
}
if cloned.NodeKeyPattern == "" {
cloned.NodeKeyPattern = "temporal_graph/nodes/%s"
}
if cloned.GraphKeyPattern == "" {
cloned.GraphKeyPattern = "temporal_graph/graph/%s"
}
if cloned.MetadataKeyPattern == "" {
cloned.MetadataKeyPattern = "temporal_graph/metadata/%s"
}
return &cloned
}
func defaultPersistenceConfig() *PersistenceConfig {
return &PersistenceConfig{
EnableLocalStorage: true,
EnableDistributedStorage: false,
EnableEncryption: false,
EncryptionRoles: []string{"default"},
SyncInterval: 15 * time.Minute,
ConflictResolutionStrategy: "latest_wins",
EnableAutoSync: false,
MaxSyncRetries: 3,
BatchSize: 1,
FlushInterval: 30 * time.Second,
EnableWriteBuffer: false,
EnableAutoBackup: false,
BackupInterval: 24 * time.Hour,
RetainBackupCount: 3,
KeyPrefix: "temporal_graph",
NodeKeyPattern: "temporal_graph/nodes/%s",
GraphKeyPattern: "temporal_graph/graph/%s",
MetadataKeyPattern: "temporal_graph/metadata/%s",
}
}
// PersistTemporalNode persists a temporal node to storage
func (pm *persistenceManagerImpl) PersistTemporalNode(ctx context.Context, node *TemporalNode) error {
pm.mu.Lock()
@@ -355,7 +422,7 @@ func (pm *persistenceManagerImpl) flushWriteBuffer() error {
for i, node := range pm.writeBuffer {
batch.Contexts[i] = &storage.ContextStoreItem{
Context: node,
Context: node.Context,
Roles: pm.config.EncryptionRoles,
}
}
@@ -419,8 +486,13 @@ func (pm *persistenceManagerImpl) loadFromLocalStorage(ctx context.Context) erro
return fmt.Errorf("failed to load metadata: %w", err)
}
var metadata *GraphMetadata
if err := json.Unmarshal(metadataData.([]byte), &metadata); err != nil {
metadataBytes, err := json.Marshal(metadataData)
if err != nil {
return fmt.Errorf("failed to marshal metadata: %w", err)
}
var metadata GraphMetadata
if err := json.Unmarshal(metadataBytes, &metadata); err != nil {
return fmt.Errorf("failed to unmarshal metadata: %w", err)
}
@@ -431,17 +503,6 @@ func (pm *persistenceManagerImpl) loadFromLocalStorage(ctx context.Context) erro
return fmt.Errorf("failed to list nodes: %w", err)
}
// Load nodes in batches
batchReq := &storage.BatchRetrieveRequest{
Keys: nodeKeys,
}
batchResult, err := pm.contextStore.BatchRetrieve(ctx, batchReq)
if err != nil {
return fmt.Errorf("failed to batch retrieve nodes: %w", err)
}
// Reconstruct graph
pm.graph.mu.Lock()
defer pm.graph.mu.Unlock()
@@ -450,17 +511,23 @@ func (pm *persistenceManagerImpl) loadFromLocalStorage(ctx context.Context) erro
pm.graph.influences = make(map[string][]string)
pm.graph.influencedBy = make(map[string][]string)
for key, result := range batchResult.Results {
if result.Error != nil {
continue // Skip failed retrievals
for _, key := range nodeKeys {
data, err := pm.localStorage.Retrieve(ctx, key)
if err != nil {
continue
}
var node *TemporalNode
if err := json.Unmarshal(result.Data.([]byte), &node); err != nil {
continue // Skip invalid nodes
nodeBytes, err := json.Marshal(data)
if err != nil {
continue
}
pm.reconstructGraphNode(node)
var node TemporalNode
if err := json.Unmarshal(nodeBytes, &node); err != nil {
continue
}
pm.reconstructGraphNode(&node)
}
return nil
@@ -695,7 +762,7 @@ func (pm *persistenceManagerImpl) identifyConflicts(local, remote *GraphSnapshot
if remoteNode, exists := remote.Nodes[nodeID]; exists {
if pm.hasNodeConflict(localNode, remoteNode) {
conflict := &SyncConflict{
Type: ConflictTypeNodeMismatch,
Type: ConflictVersionMismatch,
NodeID: nodeID,
LocalData: localNode,
RemoteData: remoteNode,
@@ -724,16 +791,19 @@ func (pm *persistenceManagerImpl) resolveConflict(ctx context.Context, conflict
}
return &ConflictResolution{
ConflictID: conflict.NodeID,
Resolution: "merged",
ResolvedData: resolvedNode,
ResolvedAt: time.Now(),
ConflictID: conflict.NodeID,
ResolutionMethod: "merged",
ResolvedAt: time.Now(),
ResolvedBy: "persistence_manager",
ResultingNode: resolvedNode,
Confidence: 1.0,
Changes: []string{"merged local and remote node"},
}, nil
}
func (pm *persistenceManagerImpl) applyConflictResolution(ctx context.Context, resolution *ConflictResolution) error {
// Apply the resolved node back to the graph
resolvedNode := resolution.ResolvedData.(*TemporalNode)
resolvedNode := resolution.ResultingNode
pm.graph.mu.Lock()
pm.graph.nodes[resolvedNode.ID] = resolvedNode

424
pkg/slurp/temporal/query_system.go
View File

@@ -3,8 +3,8 @@ package temporal
import (
"context"
"fmt"
"math"
"sort"
"strings"
"sync"
"time"
@@ -14,58 +14,58 @@ import (
// querySystemImpl implements decision-hop based query operations
type querySystemImpl struct {
mu sync.RWMutex
// Reference to the temporal graph
graph *temporalGraphImpl
graph *temporalGraphImpl
navigator DecisionNavigator
analyzer InfluenceAnalyzer
detector StalenessDetector
analyzer InfluenceAnalyzer
detector StalenessDetector
// Query optimization
queryCache map[string]interface{}
cacheTimeout time.Duration
queryCache map[string]interface{}
cacheTimeout time.Duration
lastCacheClean time.Time
// Query statistics
queryStats map[string]*QueryStatistics
}
// QueryStatistics represents statistics for different query types
type QueryStatistics struct {
QueryType string `json:"query_type"`
TotalQueries int64 `json:"total_queries"`
AverageTime time.Duration `json:"average_time"`
CacheHits int64 `json:"cache_hits"`
CacheMisses int64 `json:"cache_misses"`
LastQuery time.Time `json:"last_query"`
QueryType string `json:"query_type"`
TotalQueries int64 `json:"total_queries"`
AverageTime time.Duration `json:"average_time"`
CacheHits int64 `json:"cache_hits"`
CacheMisses int64 `json:"cache_misses"`
LastQuery time.Time `json:"last_query"`
}
// HopQuery represents a decision-hop based query
type HopQuery struct {
StartAddress ucxl.Address `json:"start_address"` // Starting point
MaxHops int `json:"max_hops"` // Maximum hops to traverse
Direction string `json:"direction"` // "forward", "backward", "both"
FilterCriteria *HopFilter `json:"filter_criteria"` // Filtering options
SortCriteria *HopSort `json:"sort_criteria"` // Sorting options
Limit int `json:"limit"` // Maximum results
IncludeMetadata bool `json:"include_metadata"` // Include detailed metadata
StartAddress ucxl.Address `json:"start_address"` // Starting point
MaxHops int `json:"max_hops"` // Maximum hops to traverse
Direction string `json:"direction"` // "forward", "backward", "both"
FilterCriteria *HopFilter `json:"filter_criteria"` // Filtering options
SortCriteria *HopSort `json:"sort_criteria"` // Sorting options
Limit int `json:"limit"` // Maximum results
IncludeMetadata bool `json:"include_metadata"` // Include detailed metadata
}
// HopFilter represents filtering criteria for hop queries
type HopFilter struct {
ChangeReasons []ChangeReason `json:"change_reasons"` // Filter by change reasons
ImpactScopes []ImpactScope `json:"impact_scopes"` // Filter by impact scopes
MinConfidence float64 `json:"min_confidence"` // Minimum confidence threshold
MaxAge time.Duration `json:"max_age"` // Maximum age of decisions
DecisionMakers []string `json:"decision_makers"` // Filter by decision makers
Tags []string `json:"tags"` // Filter by context tags
Technologies []string `json:"technologies"` // Filter by technologies
MinInfluenceCount int `json:"min_influence_count"` // Minimum number of influences
ExcludeStale bool `json:"exclude_stale"` // Exclude stale contexts
OnlyMajorDecisions bool `json:"only_major_decisions"` // Only major decisions
ChangeReasons []ChangeReason `json:"change_reasons"` // Filter by change reasons
ImpactScopes []ImpactScope `json:"impact_scopes"` // Filter by impact scopes
MinConfidence float64 `json:"min_confidence"` // Minimum confidence threshold
MaxAge time.Duration `json:"max_age"` // Maximum age of decisions
DecisionMakers []string `json:"decision_makers"` // Filter by decision makers
Tags []string `json:"tags"` // Filter by context tags
Technologies []string `json:"technologies"` // Filter by technologies
MinInfluenceCount int `json:"min_influence_count"` // Minimum number of influences
ExcludeStale bool `json:"exclude_stale"` // Exclude stale contexts
OnlyMajorDecisions bool `json:"only_major_decisions"` // Only major decisions
}
// HopSort represents sorting criteria for hop queries
// HopSort represents sorting criteria for hop queries
type HopSort struct {
SortBy string `json:"sort_by"` // "hops", "time", "confidence", "influence"
SortDirection string `json:"sort_direction"` // "asc", "desc"
@@ -74,52 +74,52 @@ type HopSort struct {
// HopQueryResult represents the result of a hop-based query
type HopQueryResult struct {
Query *HopQuery `json:"query"` // Original query
Results []*HopResult `json:"results"` // Query results
TotalFound int `json:"total_found"` // Total results found
ExecutionTime time.Duration `json:"execution_time"` // Query execution time
FromCache bool `json:"from_cache"` // Whether result came from cache
QueryPath []*QueryPathStep `json:"query_path"` // Path of query execution
Statistics *QueryExecution `json:"statistics"` // Execution statistics
Query *HopQuery `json:"query"` // Original query
Results []*HopResult `json:"results"` // Query results
TotalFound int `json:"total_found"` // Total results found
ExecutionTime time.Duration `json:"execution_time"` // Query execution time
FromCache bool `json:"from_cache"` // Whether result came from cache
QueryPath []*QueryPathStep `json:"query_path"` // Path of query execution
Statistics *QueryExecution `json:"statistics"` // Execution statistics
}
// HopResult represents a single result from a hop query
type HopResult struct {
Address ucxl.Address `json:"address"` // Context address
HopDistance int `json:"hop_distance"` // Decision hops from start
TemporalNode *TemporalNode `json:"temporal_node"` // Temporal node data
Path []*DecisionStep `json:"path"` // Path from start to this result
Relationship string `json:"relationship"` // Relationship type
RelevanceScore float64 `json:"relevance_score"` // Relevance to query
MatchReasons []string `json:"match_reasons"` // Why this matched
Metadata map[string]interface{} `json:"metadata"` // Additional metadata
Address ucxl.Address `json:"address"` // Context address
HopDistance int `json:"hop_distance"` // Decision hops from start
TemporalNode *TemporalNode `json:"temporal_node"` // Temporal node data
Path []*DecisionStep `json:"path"` // Path from start to this result
Relationship string `json:"relationship"` // Relationship type
RelevanceScore float64 `json:"relevance_score"` // Relevance to query
MatchReasons []string `json:"match_reasons"` // Why this matched
Metadata map[string]interface{} `json:"metadata"` // Additional metadata
}
// QueryPathStep represents a step in query execution path
type QueryPathStep struct {
Step int `json:"step"` // Step number
Operation string `json:"operation"` // Operation performed
NodesExamined int `json:"nodes_examined"` // Nodes examined in this step
NodesFiltered int `json:"nodes_filtered"` // Nodes filtered out
Duration time.Duration `json:"duration"` // Step duration
Description string `json:"description"` // Step description
Step int `json:"step"` // Step number
Operation string `json:"operation"` // Operation performed
NodesExamined int `json:"nodes_examined"` // Nodes examined in this step
NodesFiltered int `json:"nodes_filtered"` // Nodes filtered out
Duration time.Duration `json:"duration"` // Step duration
Description string `json:"description"` // Step description
}
// QueryExecution represents query execution statistics
type QueryExecution struct {
StartTime time.Time `json:"start_time"` // Query start time
EndTime time.Time `json:"end_time"` // Query end time
Duration time.Duration `json:"duration"` // Total duration
NodesVisited int `json:"nodes_visited"` // Total nodes visited
EdgesTraversed int `json:"edges_traversed"` // Total edges traversed
CacheAccesses int `json:"cache_accesses"` // Cache access count
FilterSteps int `json:"filter_steps"` // Number of filter steps
SortOperations int `json:"sort_operations"` // Number of sort operations
MemoryUsed int64 `json:"memory_used"` // Estimated memory used
StartTime time.Time `json:"start_time"` // Query start time
EndTime time.Time `json:"end_time"` // Query end time
Duration time.Duration `json:"duration"` // Total duration
NodesVisited int `json:"nodes_visited"` // Total nodes visited
EdgesTraversed int `json:"edges_traversed"` // Total edges traversed
CacheAccesses int `json:"cache_accesses"` // Cache access count
FilterSteps int `json:"filter_steps"` // Number of filter steps
SortOperations int `json:"sort_operations"` // Number of sort operations
MemoryUsed int64 `json:"memory_used"` // Estimated memory used
}
// NewQuerySystem creates a new decision-hop query system
func NewQuerySystem(graph *temporalGraphImpl, navigator DecisionNavigator,
func NewQuerySystem(graph *temporalGraphImpl, navigator DecisionNavigator,
analyzer InfluenceAnalyzer, detector StalenessDetector) *querySystemImpl {
return &querySystemImpl{
graph: graph,
@@ -136,12 +136,12 @@ func NewQuerySystem(graph *temporalGraphImpl, navigator DecisionNavigator,
// ExecuteHopQuery executes a decision-hop based query
func (qs *querySystemImpl) ExecuteHopQuery(ctx context.Context, query *HopQuery) (*HopQueryResult, error) {
startTime := time.Now()
// Validate query
if err := qs.validateQuery(query); err != nil {
return nil, fmt.Errorf("invalid query: %w", err)
}
// Check cache
cacheKey := qs.generateCacheKey(query)
if cached, found := qs.getFromCache(cacheKey); found {
@@ -151,26 +151,26 @@ func (qs *querySystemImpl) ExecuteHopQuery(ctx context.Context, query *HopQuery)
return result, nil
}
}
// Execute query
result, err := qs.executeHopQueryInternal(ctx, query)
if err != nil {
return nil, err
}
// Set execution time and cache result
result.ExecutionTime = time.Since(startTime)
result.FromCache = false
qs.setCache(cacheKey, result)
qs.updateQueryStats("hop_query", result.ExecutionTime, false)
return result, nil
}
// FindDecisionsWithinHops finds all decisions within N hops of a given address
func (qs *querySystemImpl) FindDecisionsWithinHops(ctx context.Context, address ucxl.Address,
func (qs *querySystemImpl) FindDecisionsWithinHops(ctx context.Context, address ucxl.Address,
maxHops int, filter *HopFilter) ([]*HopResult, error) {
query := &HopQuery{
StartAddress: address,
MaxHops: maxHops,
@@ -179,12 +179,12 @@ func (qs *querySystemImpl) FindDecisionsWithinHops(ctx context.Context, address
SortCriteria: &HopSort{SortBy: "hops", SortDirection: "asc"},
IncludeMetadata: false,
}
result, err := qs.ExecuteHopQuery(ctx, query)
if err != nil {
return nil, err
}
return result.Results, nil
}
@@ -198,31 +198,31 @@ func (qs *querySystemImpl) FindInfluenceChain(ctx context.Context, from, to ucxl
func (qs *querySystemImpl) AnalyzeDecisionGenealogy(ctx context.Context, address ucxl.Address) (*DecisionGenealogy, error) {
qs.mu.RLock()
defer qs.mu.RUnlock()
// Get evolution history
history, err := qs.graph.GetEvolutionHistory(ctx, address)
if err != nil {
return nil, fmt.Errorf("failed to get evolution history: %w", err)
}
// Get decision timeline
timeline, err := qs.navigator.GetDecisionTimeline(ctx, address, true, 10)
if err != nil {
return nil, fmt.Errorf("failed to get decision timeline: %w", err)
}
// Analyze ancestry
ancestry := qs.analyzeAncestry(history)
// Analyze descendants
// Analyze descendants
descendants := qs.analyzeDescendants(address, 5)
// Find influential ancestors
influentialAncestors := qs.findInfluentialAncestors(history)
// Calculate genealogy metrics
metrics := qs.calculateGenealogyMetrics(history, descendants)
genealogy := &DecisionGenealogy{
Address: address,
DirectAncestors: ancestry.DirectAncestors,
@@ -233,58 +233,58 @@ func (qs *querySystemImpl) AnalyzeDecisionGenealogy(ctx context.Context, address
GenealogyDepth: ancestry.MaxDepth,
BranchingFactor: descendants.BranchingFactor,
DecisionTimeline: timeline,
Metrics: metrics,
AnalyzedAt: time.Now(),
Metrics: metrics,
AnalyzedAt: time.Now(),
}
return genealogy, nil
}
// FindSimilarDecisionPatterns finds decisions with similar patterns
func (qs *querySystemImpl) FindSimilarDecisionPatterns(ctx context.Context, referenceAddress ucxl.Address,
func (qs *querySystemImpl) FindSimilarDecisionPatterns(ctx context.Context, referenceAddress ucxl.Address,
maxResults int) ([]*SimilarDecisionMatch, error) {
qs.mu.RLock()
defer qs.mu.RUnlock()
// Get reference node
refNode, err := qs.graph.getLatestNodeUnsafe(referenceAddress)
if err != nil {
return nil, fmt.Errorf("reference node not found: %w", err)
}
matches := make([]*SimilarDecisionMatch, 0)
// Compare with all other nodes
for _, node := range qs.graph.nodes {
if node.UCXLAddress.String() == referenceAddress.String() {
continue // Skip self
}
similarity := qs.calculateDecisionSimilarity(refNode, node)
if similarity > 0.3 { // Threshold for meaningful similarity
match := &SimilarDecisionMatch{
Address: node.UCXLAddress,
TemporalNode: node,
SimilarityScore: similarity,
Address: node.UCXLAddress,
TemporalNode: node,
SimilarityScore: similarity,
SimilarityReasons: qs.getSimilarityReasons(refNode, node),
PatternType: qs.identifyPatternType(refNode, node),
Confidence: similarity * 0.9, // Slightly lower confidence
PatternType: qs.identifyPatternType(refNode, node),
Confidence: similarity * 0.9, // Slightly lower confidence
}
matches = append(matches, match)
}
}
// Sort by similarity score
sort.Slice(matches, func(i, j int) bool {
return matches[i].SimilarityScore > matches[j].SimilarityScore
})
// Limit results
if maxResults > 0 && len(matches) > maxResults {
matches = matches[:maxResults]
}
return matches, nil
}
@@ -292,13 +292,13 @@ func (qs *querySystemImpl) FindSimilarDecisionPatterns(ctx context.Context, refe
func (qs *querySystemImpl) DiscoverDecisionClusters(ctx context.Context, minClusterSize int) ([]*DecisionCluster, error) {
qs.mu.RLock()
defer qs.mu.RUnlock()
// Use influence analyzer to get clusters
analysis, err := qs.analyzer.AnalyzeInfluenceNetwork(ctx)
if err != nil {
return nil, fmt.Errorf("failed to analyze influence network: %w", err)
}
// Filter clusters by minimum size
clusters := make([]*DecisionCluster, 0)
for _, community := range analysis.Communities {
@@ -307,7 +307,7 @@ func (qs *querySystemImpl) DiscoverDecisionClusters(ctx context.Context, minClus
clusters = append(clusters, cluster)
}
}
return clusters, nil
}
@@ -317,16 +317,16 @@ func (qs *querySystemImpl) executeHopQueryInternal(ctx context.Context, query *H
execution := &QueryExecution{
StartTime: time.Now(),
}
queryPath := make([]*QueryPathStep, 0)
// Step 1: Get starting node
step1Start := time.Now()
startNode, err := qs.graph.getLatestNodeUnsafe(query.StartAddress)
if err != nil {
return nil, fmt.Errorf("start node not found: %w", err)
}
queryPath = append(queryPath, &QueryPathStep{
Step: 1,
Operation: "get_start_node",
@@ -335,12 +335,12 @@ func (qs *querySystemImpl) executeHopQueryInternal(ctx context.Context, query *H
Duration: time.Since(step1Start),
Description: "Retrieved starting node",
})
// Step 2: Traverse decision graph
step2Start := time.Now()
candidates := qs.traverseDecisionGraph(startNode, query.MaxHops, query.Direction)
execution.NodesVisited = len(candidates)
queryPath = append(queryPath, &QueryPathStep{
Step: 2,
Operation: "traverse_graph",
@@ -349,12 +349,12 @@ func (qs *querySystemImpl) executeHopQueryInternal(ctx context.Context, query *H
Duration: time.Since(step2Start),
Description: fmt.Sprintf("Traversed decision graph up to %d hops", query.MaxHops),
})
// Step 3: Apply filters
step3Start := time.Now()
filtered := qs.applyFilters(candidates, query.FilterCriteria)
execution.FilterSteps = 1
queryPath = append(queryPath, &QueryPathStep{
Step: 3,
Operation: "apply_filters",
@@ -363,11 +363,11 @@ func (qs *querySystemImpl) executeHopQueryInternal(ctx context.Context, query *H
Duration: time.Since(step3Start),
Description: fmt.Sprintf("Applied filters, removed %d candidates", len(candidates)-len(filtered)),
})
// Step 4: Calculate relevance scores
step4Start := time.Now()
results := qs.calculateRelevanceScores(filtered, startNode, query)
queryPath = append(queryPath, &QueryPathStep{
Step: 4,
Operation: "calculate_relevance",
@@ -376,14 +376,14 @@ func (qs *querySystemImpl) executeHopQueryInternal(ctx context.Context, query *H
Duration: time.Since(step4Start),
Description: "Calculated relevance scores",
})
// Step 5: Sort results
step5Start := time.Time{}
if query.SortCriteria != nil {
step5Start = time.Now()
qs.sortResults(results, query.SortCriteria)
execution.SortOperations = 1
queryPath = append(queryPath, &QueryPathStep{
Step: 5,
Operation: "sort_results",
@@ -393,17 +393,17 @@ func (qs *querySystemImpl) executeHopQueryInternal(ctx context.Context, query *H
Description: fmt.Sprintf("Sorted by %s %s", query.SortCriteria.SortBy, query.SortCriteria.SortDirection),
})
}
// Step 6: Apply limit
totalFound := len(results)
if query.Limit > 0 && len(results) > query.Limit {
results = results[:query.Limit]
}
// Complete execution statistics
execution.EndTime = time.Now()
execution.Duration = execution.EndTime.Sub(execution.StartTime)
result := &HopQueryResult{
Query: query,
Results: results,
@@ -413,46 +413,46 @@ func (qs *querySystemImpl) executeHopQueryInternal(ctx context.Context, query *H
QueryPath: queryPath,
Statistics: execution,
}
return result, nil
}
func (qs *querySystemImpl) traverseDecisionGraph(startNode *TemporalNode, maxHops int, direction string) []*hopCandidate {
candidates := make([]*hopCandidate, 0)
visited := make(map[string]bool)
// BFS traversal
queue := []*hopCandidate{{
node: startNode,
distance: 0,
path: []*DecisionStep{},
}}
for len(queue) > 0 {
current := queue[0]
queue = queue[1:]
nodeID := current.node.ID
if visited[nodeID] || current.distance > maxHops {
continue
}
visited[nodeID] = true
// Add to candidates (except start node)
if current.distance > 0 {
candidates = append(candidates, current)
}
// Add neighbors based on direction
if direction == "forward" || direction == "both" {
qs.addForwardNeighbors(current, &queue, maxHops)
}
if direction == "backward" || direction == "both" {
qs.addBackwardNeighbors(current, &queue, maxHops)
}
}
return candidates
}
@@ -460,21 +460,21 @@ func (qs *querySystemImpl) applyFilters(candidates []*hopCandidate, filter *HopF
if filter == nil {
return candidates
}
filtered := make([]*hopCandidate, 0)
for _, candidate := range candidates {
if qs.passesFilter(candidate, filter) {
filtered = append(filtered, candidate)
}
}
return filtered
}
func (qs *querySystemImpl) passesFilter(candidate *hopCandidate, filter *HopFilter) bool {
node := candidate.node
// Change reason filter
if len(filter.ChangeReasons) > 0 {
found := false
@@ -488,7 +488,7 @@ func (qs *querySystemImpl) passesFilter(candidate *hopCandidate, filter *HopFilt
return false
}
}
// Impact scope filter
if len(filter.ImpactScopes) > 0 {
found := false
@@ -502,17 +502,17 @@ func (qs *querySystemImpl) passesFilter(candidate *hopCandidate, filter *HopFilt
return false
}
}
// Confidence filter
if filter.MinConfidence > 0 && node.Confidence < filter.MinConfidence {
return false
}
// Age filter
if filter.MaxAge > 0 && time.Since(node.Timestamp) > filter.MaxAge {
return false
}
// Decision maker filter
if len(filter.DecisionMakers) > 0 {
if decision, exists := qs.graph.decisions[node.DecisionID]; exists {
@@ -530,7 +530,7 @@ func (qs *querySystemImpl) passesFilter(candidate *hopCandidate, filter *HopFilt
return false // No decision metadata
}
}
// Technology filter
if len(filter.Technologies) > 0 && node.Context != nil {
found := false
@@ -549,7 +549,7 @@ func (qs *querySystemImpl) passesFilter(candidate *hopCandidate, filter *HopFilt
return false
}
}
// Tag filter
if len(filter.Tags) > 0 && node.Context != nil {
found := false
@@ -568,32 +568,32 @@ func (qs *querySystemImpl) passesFilter(candidate *hopCandidate, filter *HopFilt
return false
}
}
// Influence count filter
if filter.MinInfluenceCount > 0 && len(node.Influences) < filter.MinInfluenceCount {
return false
}
// Staleness filter
if filter.ExcludeStale && node.Staleness > 0.6 {
return false
}
// Major decisions filter
if filter.OnlyMajorDecisions && !qs.isMajorDecision(node) {
return false
}
return true
}
func (qs *querySystemImpl) calculateRelevanceScores(candidates []*hopCandidate, startNode *TemporalNode, query *HopQuery) []*HopResult {
results := make([]*HopResult, len(candidates))
for i, candidate := range candidates {
relevanceScore := qs.calculateRelevance(candidate, startNode, query)
matchReasons := qs.getMatchReasons(candidate, query.FilterCriteria)
results[i] = &HopResult{
Address: candidate.node.UCXLAddress,
HopDistance: candidate.distance,
@@ -605,26 +605,26 @@ func (qs *querySystemImpl) calculateRelevanceScores(candidates []*hopCandidate,
Metadata: qs.buildMetadata(candidate, query.IncludeMetadata),
}
}
return results
}
func (qs *querySystemImpl) calculateRelevance(candidate *hopCandidate, startNode *TemporalNode, query *HopQuery) float64 {
score := 1.0
// Distance-based relevance (closer = more relevant)
distanceScore := 1.0 - (float64(candidate.distance-1) / float64(query.MaxHops))
score *= distanceScore
// Confidence-based relevance
confidenceScore := candidate.node.Confidence
score *= confidenceScore
// Recency-based relevance
age := time.Since(candidate.node.Timestamp)
recencyScore := math.Max(0.1, 1.0-age.Hours()/(30*24)) // Decay over 30 days
score *= recencyScore
// Impact-based relevance
var impactScore float64
switch candidate.node.ImpactScope {
@@ -638,14 +638,14 @@ func (qs *querySystemImpl) calculateRelevance(candidate *hopCandidate, startNode
impactScore = 0.4
}
score *= impactScore
return math.Min(1.0, score)
}
func (qs *querySystemImpl) sortResults(results []*HopResult, sortCriteria *HopSort) {
sort.Slice(results, func(i, j int) bool {
var aVal, bVal float64
switch sortCriteria.SortBy {
case "hops":
aVal, bVal = float64(results[i].HopDistance), float64(results[j].HopDistance)
@@ -660,7 +660,7 @@ func (qs *querySystemImpl) sortResults(results []*HopResult, sortCriteria *HopSo
default:
aVal, bVal = results[i].RelevanceScore, results[j].RelevanceScore
}
if sortCriteria.SortDirection == "desc" {
return aVal > bVal
}
@@ -680,7 +680,7 @@ func (qs *querySystemImpl) addForwardNeighbors(current *hopCandidate, queue *[]*
if current.distance >= maxHops {
return
}
nodeID := current.node.ID
if influences, exists := qs.graph.influences[nodeID]; exists {
for _, influencedID := range influences {
@@ -692,7 +692,7 @@ func (qs *querySystemImpl) addForwardNeighbors(current *hopCandidate, queue *[]*
Relationship: "influences",
}
newPath := append(current.path, step)
*queue = append(*queue, &hopCandidate{
node: influencedNode,
distance: current.distance + 1,
@@ -707,7 +707,7 @@ func (qs *querySystemImpl) addBackwardNeighbors(current *hopCandidate, queue *[]
if current.distance >= maxHops {
return
}
nodeID := current.node.ID
if influencedBy, exists := qs.graph.influencedBy[nodeID]; exists {
for _, influencerID := range influencedBy {
@@ -719,7 +719,7 @@ func (qs *querySystemImpl) addBackwardNeighbors(current *hopCandidate, queue *[]
Relationship: "influenced_by",
}
newPath := append(current.path, step)
*queue = append(*queue, &hopCandidate{
node: influencerNode,
distance: current.distance + 1,
@@ -732,22 +732,22 @@ func (qs *querySystemImpl) addBackwardNeighbors(current *hopCandidate, queue *[]
func (qs *querySystemImpl) isMajorDecision(node *TemporalNode) bool {
return node.ChangeReason == ReasonArchitectureChange ||
node.ChangeReason == ReasonDesignDecision ||
node.ChangeReason == ReasonRequirementsChange ||
node.ImpactScope == ImpactSystem ||
node.ImpactScope == ImpactProject
node.ChangeReason == ReasonDesignDecision ||
node.ChangeReason == ReasonRequirementsChange ||
node.ImpactScope == ImpactSystem ||
node.ImpactScope == ImpactProject
}
func (qs *querySystemImpl) getMatchReasons(candidate *hopCandidate, filter *HopFilter) []string {
reasons := make([]string, 0)
if filter == nil {
reasons = append(reasons, "no_filters_applied")
return reasons
}
node := candidate.node
if len(filter.ChangeReasons) > 0 {
for _, reason := range filter.ChangeReasons {
if node.ChangeReason == reason {
@@ -755,7 +755,7 @@ func (qs *querySystemImpl) getMatchReasons(candidate *hopCandidate, filter *HopF
}
}
}
if len(filter.ImpactScopes) > 0 {
for _, scope := range filter.ImpactScopes {
if node.ImpactScope == scope {
@@ -763,15 +763,15 @@ func (qs *querySystemImpl) getMatchReasons(candidate *hopCandidate, filter *HopF
}
}
}
if filter.MinConfidence > 0 && node.Confidence >= filter.MinConfidence {
reasons = append(reasons, fmt.Sprintf("confidence: %.2f >= %.2f", node.Confidence, filter.MinConfidence))
}
if filter.MinInfluenceCount > 0 && len(node.Influences) >= filter.MinInfluenceCount {
reasons = append(reasons, fmt.Sprintf("influence_count: %d >= %d", len(node.Influences), filter.MinInfluenceCount))
}
return reasons
}
@@ -779,7 +779,7 @@ func (qs *querySystemImpl) determineRelationship(candidate *hopCandidate, startN
if len(candidate.path) == 0 {
return "self"
}
// Look at the last step in the path
lastStep := candidate.path[len(candidate.path)-1]
return lastStep.Relationship
@@ -787,12 +787,12 @@ func (qs *querySystemImpl) determineRelationship(candidate *hopCandidate, startN
func (qs *querySystemImpl) buildMetadata(candidate *hopCandidate, includeDetailed bool) map[string]interface{} {
metadata := make(map[string]interface{})
metadata["hop_distance"] = candidate.distance
metadata["path_length"] = len(candidate.path)
metadata["node_id"] = candidate.node.ID
metadata["decision_id"] = candidate.node.DecisionID
if includeDetailed {
metadata["timestamp"] = candidate.node.Timestamp
metadata["change_reason"] = candidate.node.ChangeReason
@@ -801,19 +801,19 @@ func (qs *querySystemImpl) buildMetadata(candidate *hopCandidate, includeDetaile
metadata["staleness"] = candidate.node.Staleness
metadata["influence_count"] = len(candidate.node.Influences)
metadata["influenced_by_count"] = len(candidate.node.InfluencedBy)
if candidate.node.Context != nil {
metadata["context_summary"] = candidate.node.Context.Summary
metadata["technologies"] = candidate.node.Context.Technologies
metadata["tags"] = candidate.node.Context.Tags
}
if decision, exists := qs.graph.decisions[candidate.node.DecisionID]; exists {
metadata["decision_maker"] = decision.Maker
metadata["decision_rationale"] = decision.Rationale
}
}
return metadata
}
@@ -823,26 +823,26 @@ func (qs *querySystemImpl) validateQuery(query *HopQuery) error {
if err := query.StartAddress.Validate(); err != nil {
return fmt.Errorf("invalid start address: %w", err)
}
if query.MaxHops < 1 || query.MaxHops > 20 {
return fmt.Errorf("max hops must be between 1 and 20")
}
if query.Direction != "" && query.Direction != "forward" && query.Direction != "backward" && query.Direction != "both" {
return fmt.Errorf("direction must be 'forward', 'backward', or 'both'")
}
if query.Limit < 0 {
return fmt.Errorf("limit cannot be negative")
}
return nil
}
func (qs *querySystemImpl) generateCacheKey(query *HopQuery) string {
return fmt.Sprintf("hop_query_%s_%d_%s_%v",
query.StartAddress.String(),
query.MaxHops,
return fmt.Sprintf("hop_query_%s_%d_%s_%v",
query.StartAddress.String(),
query.MaxHops,
query.Direction,
query.FilterCriteria != nil)
}
@@ -850,7 +850,7 @@ func (qs *querySystemImpl) generateCacheKey(query *HopQuery) string {
func (qs *querySystemImpl) getFromCache(key string) (interface{}, bool) {
qs.mu.RLock()
defer qs.mu.RUnlock()
value, exists := qs.queryCache[key]
return value, exists
}
@@ -858,36 +858,36 @@ func (qs *querySystemImpl) getFromCache(key string) (interface{}, bool) {
func (qs *querySystemImpl) setCache(key string, value interface{}) {
qs.mu.Lock()
defer qs.mu.Unlock()
// Clean cache if needed
if time.Since(qs.lastCacheClean) > qs.cacheTimeout {
qs.queryCache = make(map[string]interface{})
qs.lastCacheClean = time.Now()
}
qs.queryCache[key] = value
}
func (qs *querySystemImpl) updateQueryStats(queryType string, duration time.Duration, cacheHit bool) {
qs.mu.Lock()
defer qs.mu.Unlock()
stats, exists := qs.queryStats[queryType]
if !exists {
stats = &QueryStatistics{QueryType: queryType}
qs.queryStats[queryType] = stats
}
stats.TotalQueries++
stats.LastQuery = time.Now()
// Update average time
if stats.AverageTime == 0 {
stats.AverageTime = duration
} else {
stats.AverageTime = (stats.AverageTime + duration) / 2
}
if cacheHit {
stats.CacheHits++
} else {
@@ -901,42 +901,42 @@ func (qs *querySystemImpl) updateQueryStats(queryType string, duration time.Dura
// DecisionGenealogy represents the genealogy of decisions for a context
type DecisionGenealogy struct {
Address ucxl.Address `json:"address"`
DirectAncestors []ucxl.Address `json:"direct_ancestors"`
AllAncestors []ucxl.Address `json:"all_ancestors"`
DirectDescendants []ucxl.Address `json:"direct_descendants"`
AllDescendants []ucxl.Address `json:"all_descendants"`
InfluentialAncestors []*InfluentialAncestor `json:"influential_ancestors"`
GenealogyDepth int `json:"genealogy_depth"`
BranchingFactor float64 `json:"branching_factor"`
DecisionTimeline *DecisionTimeline `json:"decision_timeline"`
Metrics *GenealogyMetrics `json:"metrics"`
AnalyzedAt time.Time `json:"analyzed_at"`
Address ucxl.Address `json:"address"`
DirectAncestors []ucxl.Address `json:"direct_ancestors"`
AllAncestors []ucxl.Address `json:"all_ancestors"`
DirectDescendants []ucxl.Address `json:"direct_descendants"`
AllDescendants []ucxl.Address `json:"all_descendants"`
InfluentialAncestors []*InfluentialAncestor `json:"influential_ancestors"`
GenealogyDepth int `json:"genealogy_depth"`
BranchingFactor float64 `json:"branching_factor"`
DecisionTimeline *DecisionTimeline `json:"decision_timeline"`
Metrics *GenealogyMetrics `json:"metrics"`
AnalyzedAt time.Time `json:"analyzed_at"`
}
// Additional supporting types for genealogy and similarity analysis...
type InfluentialAncestor struct {
Address ucxl.Address `json:"address"`
InfluenceScore float64 `json:"influence_score"`
GenerationsBack int `json:"generations_back"`
InfluenceType string `json:"influence_type"`
Address ucxl.Address `json:"address"`
InfluenceScore float64 `json:"influence_score"`
GenerationsBack int `json:"generations_back"`
InfluenceType string `json:"influence_type"`
}
type GenealogyMetrics struct {
TotalAncestors int `json:"total_ancestors"`
TotalDescendants int `json:"total_descendants"`
MaxDepth int `json:"max_depth"`
AverageBranching float64 `json:"average_branching"`
InfluenceSpread float64 `json:"influence_spread"`
TotalAncestors int `json:"total_ancestors"`
TotalDescendants int `json:"total_descendants"`
MaxDepth int `json:"max_depth"`
AverageBranching float64 `json:"average_branching"`
InfluenceSpread float64 `json:"influence_spread"`
}
type SimilarDecisionMatch struct {
Address ucxl.Address `json:"address"`
TemporalNode *TemporalNode `json:"temporal_node"`
SimilarityScore float64 `json:"similarity_score"`
SimilarityReasons []string `json:"similarity_reasons"`
PatternType string `json:"pattern_type"`
Confidence float64 `json:"confidence"`
Address ucxl.Address `json:"address"`
TemporalNode *TemporalNode `json:"temporal_node"`
SimilarityScore float64 `json:"similarity_score"`
SimilarityReasons []string `json:"similarity_reasons"`
PatternType string `json:"pattern_type"`
Confidence float64 `json:"confidence"`
}
// Placeholder implementations for the analysis methods
@@ -978,10 +978,10 @@ func (qs *querySystemImpl) identifyPatternType(node1, node2 *TemporalNode) strin
func (qs *querySystemImpl) convertCommunityToCluster(community Community) *DecisionCluster {
// Implementation would convert community to decision cluster
return &DecisionCluster{
ID: community.ID,
Decisions: community.Nodes,
ID: community.ID,
Decisions: community.Nodes,
ClusterSize: len(community.Nodes),
Cohesion: community.Modularity,
Cohesion: community.Modularity,
}
}
@@ -996,4 +996,4 @@ type descendantAnalysis struct {
DirectDescendants []ucxl.Address
AllDescendants []ucxl.Address
BranchingFactor float64
}
}

106
pkg/slurp/temporal/temporal_stub_test.go Normal file
View File

@@ -0,0 +1,106 @@
//go:build !slurp_full
// +build !slurp_full
package temporal
import (
"context"
"fmt"
"testing"
)
func TestTemporalGraphStubBasicLifecycle(t *testing.T) {
storage := newMockStorage()
graph := NewTemporalGraph(storage)
ctx := context.Background()
address := createTestAddress("stub/basic")
contextNode := createTestContext("stub/basic", []string{"go"})
node, err := graph.CreateInitialContext(ctx, address, contextNode, "tester")
if err != nil {
t.Fatalf("expected initial context creation to succeed, got error: %v", err)
}
if node == nil {
t.Fatal("expected non-nil temporal node for initial context")
}
decision := createTestDecision("stub-dec-001", "tester", "initial evolution", ImpactLocal)
evolved, err := graph.EvolveContext(ctx, address, createTestContext("stub/basic", []string{"go", "feature"}), ReasonCodeChange, decision)
if err != nil {
t.Fatalf("expected context evolution to succeed, got error: %v", err)
}
if evolved.Version != node.Version+1 {
t.Fatalf("expected version to increment, got %d after %d", evolved.Version, node.Version)
}
latest, err := graph.GetLatestVersion(ctx, address)
if err != nil {
t.Fatalf("expected latest version retrieval to succeed, got error: %v", err)
}
if latest.Version != evolved.Version {
t.Fatalf("expected latest version %d, got %d", evolved.Version, latest.Version)
}
}
func TestTemporalInfluenceAnalyzerStub(t *testing.T) {
storage := newMockStorage()
graph := NewTemporalGraph(storage).(*temporalGraphImpl)
analyzer := NewInfluenceAnalyzer(graph)
ctx := context.Background()
addrA := createTestAddress("stub/serviceA")
addrB := createTestAddress("stub/serviceB")
if _, err := graph.CreateInitialContext(ctx, addrA, createTestContext("stub/serviceA", []string{"go"}), "tester"); err != nil {
t.Fatalf("failed to create context A: %v", err)
}
if _, err := graph.CreateInitialContext(ctx, addrB, createTestContext("stub/serviceB", []string{"go"}), "tester"); err != nil {
t.Fatalf("failed to create context B: %v", err)
}
if err := graph.AddInfluenceRelationship(ctx, addrA, addrB); err != nil {
t.Fatalf("expected influence relationship to succeed, got error: %v", err)
}
analysis, err := analyzer.AnalyzeInfluenceNetwork(ctx)
if err != nil {
t.Fatalf("expected influence analysis to succeed, got error: %v", err)
}
if analysis.TotalNodes == 0 {
t.Fatal("expected influence analysis to report at least one node")
}
}
func TestTemporalDecisionNavigatorStub(t *testing.T) {
storage := newMockStorage()
graph := NewTemporalGraph(storage).(*temporalGraphImpl)
navigator := NewDecisionNavigator(graph)
ctx := context.Background()
address := createTestAddress("stub/navigator")
if _, err := graph.CreateInitialContext(ctx, address, createTestContext("stub/navigator", []string{"go"}), "tester"); err != nil {
t.Fatalf("failed to create initial context: %v", err)
}
for i := 2; i <= 3; i++ {
id := fmt.Sprintf("stub-hop-%03d", i)
decision := createTestDecision(id, "tester", "hop", ImpactLocal)
if _, err := graph.EvolveContext(ctx, address, createTestContext("stub/navigator", []string{"go", "v"}), ReasonCodeChange, decision); err != nil {
t.Fatalf("failed to evolve context to version %d: %v", i, err)
}
}
timeline, err := navigator.GetDecisionTimeline(ctx, address, false, 0)
if err != nil {
t.Fatalf("expected timeline retrieval to succeed, got error: %v", err)
}
if timeline == nil || timeline.TotalDecisions == 0 {
t.Fatal("expected non-empty decision timeline")
}
}

132
pkg/slurp/temporal/test_helpers.go Normal file
View File

@@ -0,0 +1,132 @@
package temporal
import (
"context"
"fmt"
"time"
slurpContext "chorus/pkg/slurp/context"
"chorus/pkg/slurp/storage"
"chorus/pkg/ucxl"
)
// mockStorage provides an in-memory implementation of the storage interfaces used by temporal tests.
type mockStorage struct {
data map[string]interface{}
}
func newMockStorage() *mockStorage {
return &mockStorage{
data: make(map[string]interface{}),
}
}
func (ms *mockStorage) StoreContext(ctx context.Context, node *slurpContext.ContextNode, roles []string) error {
ms.data[node.UCXLAddress.String()] = node
return nil
}
func (ms *mockStorage) RetrieveContext(ctx context.Context, address ucxl.Address, role string) (*slurpContext.ContextNode, error) {
if data, exists := ms.data[address.String()]; exists {
return data.(*slurpContext.ContextNode), nil
}
return nil, storage.ErrNotFound
}
func (ms *mockStorage) UpdateContext(ctx context.Context, node *slurpContext.ContextNode, roles []string) error {
ms.data[node.UCXLAddress.String()] = node
return nil
}
func (ms *mockStorage) DeleteContext(ctx context.Context, address ucxl.Address) error {
delete(ms.data, address.String())
return nil
}
func (ms *mockStorage) ExistsContext(ctx context.Context, address ucxl.Address) (bool, error) {
_, exists := ms.data[address.String()]
return exists, nil
}
func (ms *mockStorage) ListContexts(ctx context.Context, criteria *storage.ListCriteria) ([]*slurpContext.ContextNode, error) {
results := make([]*slurpContext.ContextNode, 0)
for _, data := range ms.data {
if node, ok := data.(*slurpContext.ContextNode); ok {
results = append(results, node)
}
}
return results, nil
}
func (ms *mockStorage) SearchContexts(ctx context.Context, query *storage.SearchQuery) (*storage.SearchResults, error) {
return &storage.SearchResults{}, nil
}
func (ms *mockStorage) BatchStore(ctx context.Context, batch *storage.BatchStoreRequest) (*storage.BatchStoreResult, error) {
return &storage.BatchStoreResult{}, nil
}
func (ms *mockStorage) BatchRetrieve(ctx context.Context, batch *storage.BatchRetrieveRequest) (*storage.BatchRetrieveResult, error) {
return &storage.BatchRetrieveResult{}, nil
}
func (ms *mockStorage) GetStorageStats(ctx context.Context) (*storage.StorageStatistics, error) {
return &storage.StorageStatistics{}, nil
}
func (ms *mockStorage) Sync(ctx context.Context) error {
return nil
}
func (ms *mockStorage) Backup(ctx context.Context, destination string) error {
return nil
}
func (ms *mockStorage) Restore(ctx context.Context, source string) error {
return nil
}
// createTestAddress constructs a deterministic UCXL address for test scenarios.
func createTestAddress(path string) ucxl.Address {
return ucxl.Address{
Agent: "test-agent",
Role: "tester",
Project: "test-project",
Task: "unit-test",
TemporalSegment: ucxl.TemporalSegment{
Type: ucxl.TemporalLatest,
},
Path: path,
Raw: fmt.Sprintf("ucxl://test-agent:tester@test-project:unit-test/*^/%s", path),
}
}
// createTestContext prepares a lightweight context node for graph operations.
func createTestContext(path string, technologies []string) *slurpContext.ContextNode {
return &slurpContext.ContextNode{
Path: path,
UCXLAddress: createTestAddress(path),
Summary: fmt.Sprintf("Test context for %s", path),
Purpose: fmt.Sprintf("Test purpose for %s", path),
Technologies: technologies,
Tags: []string{"test"},
Insights: []string{"test insight"},
GeneratedAt: time.Now(),
RAGConfidence: 0.8,
}
}
// createTestDecision fabricates decision metadata to drive evolution in tests.
func createTestDecision(id, maker, rationale string, scope ImpactScope) *DecisionMetadata {
return &DecisionMetadata{
ID: id,
Maker: maker,
Rationale: rationale,
Scope: scope,
ConfidenceLevel: 0.8,
ExternalRefs: []string{},
CreatedAt: time.Now(),
ImplementationStatus: "complete",
Metadata: make(map[string]interface{}),
}
}