terraphim_goal_alignment 1.0.0

Knowledge graph-based goal alignment system for multi-level goal management and conflict resolution
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

//! Error types for the goal alignment system

use crate::{AgentPid, GoalId};
use thiserror::Error;

/// Errors that can occur in the goal alignment system
#[derive(Error, Debug)]
pub enum GoalAlignmentError {
    #[error("Goal {0} not found")]
    GoalNotFound(GoalId),

    #[error("Goal {0} already exists")]
    GoalAlreadyExists(GoalId),

    #[error("Goal hierarchy validation failed: {0}")]
    HierarchyValidationFailed(String),

    #[error("Goal conflict detected between {0} and {1}: {2}")]
    GoalConflict(GoalId, GoalId, String),

    #[error("Goal propagation failed: {0}")]
    PropagationFailed(String),

    #[error("Knowledge graph operation failed: {0}")]
    KnowledgeGraphError(String),

    #[error("Role graph operation failed: {0}")]
    RoleGraphError(String),

    #[error("Goal alignment validation failed for {0}: {1}")]
    AlignmentValidationFailed(GoalId, String),

    #[error("Agent {0} not found for goal assignment")]
    AgentNotFound(AgentPid),

    #[error("Invalid goal specification for {0}: {1}")]
    InvalidGoalSpec(GoalId, String),

    #[error("Goal dependency cycle detected: {0}")]
    DependencyCycle(String),

    #[error("Goal constraint violation: {0}")]
    ConstraintViolation(String),

    #[error("Serialization error: {0}")]
    Serialization(#[from] serde_json::Error),

    #[error("System error: {0}")]
    System(String),
}

impl GoalAlignmentError {
    /// Check if this error is recoverable
    pub fn is_recoverable(&self) -> bool {
        match self {
            GoalAlignmentError::GoalNotFound(_) => true,
            GoalAlignmentError::GoalAlreadyExists(_) => false,
            GoalAlignmentError::HierarchyValidationFailed(_) => true,
            GoalAlignmentError::GoalConflict(_, _, _) => true,
            GoalAlignmentError::PropagationFailed(_) => true,
            GoalAlignmentError::KnowledgeGraphError(_) => true,
            GoalAlignmentError::RoleGraphError(_) => true,
            GoalAlignmentError::AlignmentValidationFailed(_, _) => true,
            GoalAlignmentError::AgentNotFound(_) => true,
            GoalAlignmentError::InvalidGoalSpec(_, _) => false,
            GoalAlignmentError::DependencyCycle(_) => false,
            GoalAlignmentError::ConstraintViolation(_) => true,
            GoalAlignmentError::Serialization(_) => false,
            GoalAlignmentError::System(_) => false,
        }
    }

    /// Get error category for monitoring
    pub fn category(&self) -> ErrorCategory {
        match self {
            GoalAlignmentError::GoalNotFound(_) => ErrorCategory::NotFound,
            GoalAlignmentError::GoalAlreadyExists(_) => ErrorCategory::Conflict,
            GoalAlignmentError::HierarchyValidationFailed(_) => ErrorCategory::Validation,
            GoalAlignmentError::GoalConflict(_, _, _) => ErrorCategory::Conflict,
            GoalAlignmentError::PropagationFailed(_) => ErrorCategory::Propagation,
            GoalAlignmentError::KnowledgeGraphError(_) => ErrorCategory::KnowledgeGraph,
            GoalAlignmentError::RoleGraphError(_) => ErrorCategory::RoleGraph,
            GoalAlignmentError::AlignmentValidationFailed(_, _) => ErrorCategory::Validation,
            GoalAlignmentError::AgentNotFound(_) => ErrorCategory::NotFound,
            GoalAlignmentError::InvalidGoalSpec(_, _) => ErrorCategory::Validation,
            GoalAlignmentError::DependencyCycle(_) => ErrorCategory::Validation,
            GoalAlignmentError::ConstraintViolation(_) => ErrorCategory::Constraint,
            GoalAlignmentError::Serialization(_) => ErrorCategory::Serialization,
            GoalAlignmentError::System(_) => ErrorCategory::System,
        }
    }
}

/// Error categories for monitoring and alerting
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ErrorCategory {
    NotFound,
    Conflict,
    Validation,
    Propagation,
    KnowledgeGraph,
    RoleGraph,
    Constraint,
    Serialization,
    System,
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_error_recoverability() {
        let recoverable_error = GoalAlignmentError::GoalNotFound("test_goal".to_string());
        assert!(recoverable_error.is_recoverable());

        let non_recoverable_error = GoalAlignmentError::InvalidGoalSpec(
            "test_goal".to_string(),
            "invalid spec".to_string(),
        );
        assert!(!non_recoverable_error.is_recoverable());
    }

    #[test]
    fn test_error_categorization() {
        let not_found_error = GoalAlignmentError::GoalNotFound("test_goal".to_string());
        assert_eq!(not_found_error.category(), ErrorCategory::NotFound);

        let conflict_error = GoalAlignmentError::GoalConflict(
            "goal1".to_string(),
            "goal2".to_string(),
            "conflicting objectives".to_string(),
        );
        assert_eq!(conflict_error.category(), ErrorCategory::Conflict);
    }
}