khive-fold 0.2.0

Cognitive primitives — Fold, Anchor, Objective, Selector
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

//! Error types for khive-fold

use thiserror::Error;
use uuid::Uuid;

/// Result type for fold operations
pub type FoldResult<T> = std::result::Result<T, FoldError>;

/// Errors that can occur in fold operations
#[derive(Error, Debug)]
pub enum FoldError {
    /// Entry not found
    #[error("Entry {0} not found")]
    EntryNotFound(Uuid),

    /// Invalid entry type for this fold
    #[error("Invalid entry type: expected {expected}, got {actual}")]
    InvalidEntryType {
        /// The expected entry type name
        expected: String,
        /// The actual entry type that was provided
        actual: String,
    },

    /// Fold context error
    #[error("Context error: {0}")]
    Context(String),

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

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

    /// Internal lock poisoned (concurrent panic)
    #[error("Internal lock poisoned: {0}")]
    LockPoisoned(String),

    /// Invalid input to a cognitive primitive (Anchor, Selector).
    #[error("invalid input: {0}")]
    InvalidInput(String),

    /// Budget exhausted during selection.
    #[error("budget exhausted: needed {needed}, have {budget}")]
    BudgetExhausted {
        /// Budget needed.
        needed: usize,
        /// Budget available.
        budget: usize,
    },

    /// Anchor not found during graph traversal.
    #[error("anchor not found: {0}")]
    AnchorNotFound(String),

    /// Required component not configured.
    #[error("required component not configured: {0}")]
    ComponentMissing(String),
}

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

    #[test]
    fn test_entry_not_found_display() {
        let id = Uuid::new_v4();
        let err = FoldError::EntryNotFound(id);
        assert!(err.to_string().contains(&id.to_string()));
    }

    #[test]
    fn test_invalid_entry_type_display() {
        let err = FoldError::InvalidEntryType {
            expected: "data".into(),
            actual: "item".into(),
        };
        let msg = err.to_string();
        assert!(msg.contains("data"));
        assert!(msg.contains("item"));
    }

    #[test]
    fn test_context_display() {
        let err = FoldError::Context("missing budget".into());
        assert!(err.to_string().contains("missing budget"));
    }

    #[test]
    fn test_from_serde_error() {
        let json_err: serde_json::Error = serde_json::from_str::<i32>("invalid").unwrap_err();
        let err: FoldError = json_err.into();
        assert!(matches!(err, FoldError::Serialization(_)));
    }

    #[test]
    fn test_budget_exhausted_display() {
        let err = FoldError::BudgetExhausted {
            needed: 100,
            budget: 50,
        };
        let msg = err.to_string();
        assert!(msg.contains("100"));
        assert!(msg.contains("50"));
    }

    #[test]
    fn test_anchor_not_found_display() {
        let err = FoldError::AnchorNotFound("my-anchor".into());
        assert!(err.to_string().contains("my-anchor"));
    }
}