terraphim_task_decomposition 1.0.0

Knowledge graph-based task decomposition system for intelligent task analysis and execution planning
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
137

//! Error types for the task decomposition system

use crate::TaskId;
use thiserror::Error;

/// Errors that can occur in the task decomposition system
#[derive(Error, Debug)]
pub enum TaskDecompositionError {
    #[error("Task {0} not found")]
    TaskNotFound(TaskId),

    #[error("Task {0} already exists")]
    TaskAlreadyExists(TaskId),

    #[error("Task decomposition failed for {0}: {1}")]
    DecompositionFailed(TaskId, String),

    #[error("Task analysis failed for {0}: {1}")]
    AnalysisFailed(TaskId, String),

    #[error("Execution plan generation failed: {0}")]
    PlanGenerationFailed(String),

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

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

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

    #[error("Invalid task specification for {0}: {1}")]
    InvalidTaskSpec(TaskId, String),

    #[error("Task complexity analysis failed for {0}: {1}")]
    ComplexityAnalysisFailed(TaskId, String),

    #[error("Agent assignment failed for task {0}: {1}")]
    AgentAssignmentFailed(TaskId, String),

    #[error("Task execution planning failed: {0}")]
    ExecutionPlanningFailed(String),

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

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

impl TaskDecompositionError {
    /// Check if this error is recoverable
    pub fn is_recoverable(&self) -> bool {
        match self {
            TaskDecompositionError::TaskNotFound(_) => true,
            TaskDecompositionError::TaskAlreadyExists(_) => false,
            TaskDecompositionError::DecompositionFailed(_, _) => true,
            TaskDecompositionError::AnalysisFailed(_, _) => true,
            TaskDecompositionError::PlanGenerationFailed(_) => true,
            TaskDecompositionError::KnowledgeGraphError(_) => true,
            TaskDecompositionError::RoleGraphError(_) => true,
            TaskDecompositionError::DependencyCycle(_) => false,
            TaskDecompositionError::InvalidTaskSpec(_, _) => false,
            TaskDecompositionError::ComplexityAnalysisFailed(_, _) => true,
            TaskDecompositionError::AgentAssignmentFailed(_, _) => true,
            TaskDecompositionError::ExecutionPlanningFailed(_) => true,
            TaskDecompositionError::Serialization(_) => false,
            TaskDecompositionError::System(_) => false,
        }
    }

    /// Get error category for monitoring
    pub fn category(&self) -> ErrorCategory {
        match self {
            TaskDecompositionError::TaskNotFound(_) => ErrorCategory::NotFound,
            TaskDecompositionError::TaskAlreadyExists(_) => ErrorCategory::Conflict,
            TaskDecompositionError::DecompositionFailed(_, _) => ErrorCategory::Decomposition,
            TaskDecompositionError::AnalysisFailed(_, _) => ErrorCategory::Analysis,
            TaskDecompositionError::PlanGenerationFailed(_) => ErrorCategory::Planning,
            TaskDecompositionError::KnowledgeGraphError(_) => ErrorCategory::KnowledgeGraph,
            TaskDecompositionError::RoleGraphError(_) => ErrorCategory::RoleGraph,
            TaskDecompositionError::DependencyCycle(_) => ErrorCategory::Validation,
            TaskDecompositionError::InvalidTaskSpec(_, _) => ErrorCategory::Validation,
            TaskDecompositionError::ComplexityAnalysisFailed(_, _) => ErrorCategory::Analysis,
            TaskDecompositionError::AgentAssignmentFailed(_, _) => ErrorCategory::Assignment,
            TaskDecompositionError::ExecutionPlanningFailed(_) => ErrorCategory::Planning,
            TaskDecompositionError::Serialization(_) => ErrorCategory::Serialization,
            TaskDecompositionError::System(_) => ErrorCategory::System,
        }
    }
}

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

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

    #[test]
    fn test_error_recoverability() {
        let recoverable_error = TaskDecompositionError::TaskNotFound("test_task".to_string());
        assert!(recoverable_error.is_recoverable());

        let non_recoverable_error = TaskDecompositionError::InvalidTaskSpec(
            "test_task".to_string(),
            "invalid spec".to_string(),
        );
        assert!(!non_recoverable_error.is_recoverable());
    }

    #[test]
    fn test_error_categorization() {
        let not_found_error = TaskDecompositionError::TaskNotFound("test_task".to_string());
        assert_eq!(not_found_error.category(), ErrorCategory::NotFound);

        let decomposition_error = TaskDecompositionError::DecompositionFailed(
            "test_task".to_string(),
            "decomposition failed".to_string(),
        );
        assert_eq!(decomposition_error.category(), ErrorCategory::Decomposition);
    }
}